Changeset 5768


Ignore:
Timestamp:
May 13, 2012 2:34:49 PM (7 years ago)
Author:
wehart
Message:

Removing the Var._varval dictionary. Instead, the
IndexedComponent?._data dictionary is now used.

Location:
coopr.pyomo/trunk/coopr/pyomo
Files:
6 edited

Legend:

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

    r5633 r5768  
    229229        else:
    230230            # if the dimension is a singleton (i.e., we're dealing
    231             # with a _ConElement), and the _varval is already initialized.
     231            # with a _ConElement), and the _data is already initialized.
    232232            pass
    233233
  • coopr.pyomo/trunk/coopr/pyomo/base/var.py

    r5762 r5768  
    295295
    296296        self._defer_domain = False
    297 
    298         # the guts of the class - maps indicies to _VarData objects.
    299         self._varval = {}
    300297
    301298        self._attr_declarations = {} # maps the name of an attribute (i.e., a suffix) to its default value.
     
    392389
    393390    def as_numeric(self):
    394         if None in self._varval:
    395             return self._varval[None]
     391        if None in self._data:
     392            return self._data[None]
    396393        return self
    397394
     
    406403
    407404    def keys(self):
    408         return self._varval.keys()
     405        return self._data.keys()
    409406
    410407    # returns a dictionary of index-value pairs.
    411408    def extract_values(self):
    412         return dict(((index, varval.value) for index, varval in self._varval.iteritems()))
     409        return dict(((index, varval.value) for index, varval in self._data.iteritems()))
    413410
    414411    # takes as input a dictionary of index-value pairs.
    415412    def store_values(self, new_values):
    416         for index, varval in self._varval.iteritems():
     413        for index, varval in self._data.iteritems():
    417414            varval.value = new_values[index]
    418415
     
    439436        if self._domain_rule is None:
    440437            if self._is_binary:
    441                 return self._varval.keys()
     438                return self._data.keys()
    442439            else:
    443440                return []
     
    449446        if self._domain_rule is None:
    450447            if self._is_integer:
    451                 return self._varval.keys()
     448                return self._data.keys()
    452449            else:
    453450                return []
     
    459456        if self._domain_rule is None:
    460457            if self._is_continuous:
    461                 return self._varval.keys()
     458                return self._data.keys()
    462459            else:
    463460                return []
     
    466463
    467464    def __iter__(self):
    468         return self._varval.iterkeys()
     465        return self._data.iterkeys()
    469466
    470467    def iterkeys(self):
    471         return self._varval.iterkeys()
     468        return self._data.iterkeys()
    472469
    473470    def itervalues(self):
    474         return self._varval.itervalues()
     471        return self._data.itervalues()
    475472
    476473    def iteritems(self):
    477         return self._varval.iteritems()
     474        return self._data.iteritems()
    478475
    479476    def __contains__(self, ndx):
    480         return ndx in self._varval
     477        return ndx in self._data
    481478
    482479    def dim(self):
     
    484481
    485482    def reset(self):
    486         for value in self._varval.itervalues():
     483        for value in self._data.itervalues():
    487484            value.set_value(value.initial)
    488485
    489486    def __len__(self):
    490         return len(self._varval)
     487        return len(self._data)
    491488
    492489    def __setitem__(self,ndx,val):
     
    505502            msg = "Cannot set variable '%s[%s]' with invalid value: %s"
    506503            raise ValueError, msg % ( self.name, str(ndx), str(val) )
    507         self._varval[ndx].value = val
     504        self._data[ndx].value = val
    508505
    509506    def __getitem__(self,ndx):
     
    513510        """
    514511        try:
    515             return self._varval[ndx]
     512            return self._data[ndx]
    516513        except KeyError: # thrown if the supplied index is hashable, but not defined.
    517514            msg = "Unknown index '%s' in variable %s;" % (str(ndx), self.name)
     
    541538            domain = self.domain
    542539
    543         new_varval = _VarData(create_name(self.name,ndx), domain, self)
    544         new_varval.index = ndx
     540        new_data = _VarData(create_name(self.name,ndx), domain, self)
     541        new_data.index = ndx
    545542       
    546         self._varval[ndx] = new_varval
     543        self._data[ndx] = new_data
    547544
    548545
     
    577574        if self._domain_rule is None:
    578575            if isinstance(self.domain, BooleanSet):
    579                 self._binary_keys = self._varval.keys()
     576                self._binary_keys = self._data.keys()
    580577            elif isinstance(self.domain, IntegerSet):
    581                 self._integer_keys = self._varval.keys()
     578                self._integer_keys = self._data.keys()
    582579            else:
    583                 self._continuous_keys = self._varval.keys()
     580                self._continuous_keys = self._data.keys()
    584581
    585582        #
     
    591588            #
    592589            if self._initialize.__class__ is types.FunctionType:
    593                 for key in self._varval:
     590                for key in self._data:
    594591                    if key is None:
    595592                        val = self._initialize(self._model())
     
    599596                    val = value(val)
    600597                    self._valid_value(val, True)
    601                     self._varval[key].value = self._varval[key].initial = val
     598                    self._data[key].value = self._data[key].initial = val
    602599            elif self._initialize.__class__ is dict:
    603600                for key in self._initialize:
    604601                    val = self._initialize[key]
    605602                    self._valid_value(val, True)
    606                     self._varval[key].value = self._varval[key].initial = val
     603                    self._data[key].value = self._data[key].initial = val
    607604            else:
    608605                for key in self._index:
    609606                    val = self._initialize
    610607                    self._valid_value(val, True)
    611                     self._varval[key].value = self._varval[key].initial = val
     608                    self._data[key].value = self._data[key].initial = val
    612609        #
    613610        # Initialize bounds with the bounds function if provided
     
    627624                    ub = None
    628625
    629                 for key,varval in self._varval.iteritems():
     626                for key,varval in self._data.iteritems():
    630627                    if lb is not None:
    631628                        varval.setlb(lb)
     
    637634                # bounds are specified via a function
    638635
    639                 for index, varval in self._varval.iteritems():
     636                for index, varval in self._data.iteritems():
    640637                    if index is None:
    641638                        (lb, ub) = self.bounds(self._model())
     
    646643                    varval.setub(ub)
    647644
    648                 for varval in self._varval.itervalues():
     645                for varval in self._data.itervalues():
    649646                    if varval.lb is not None and not pyutilib.math.is_finite(varval.lb()):
    650647                        varval.setlb(None)
     
    662659            dbounds = self.domain.bounds()
    663660            if not dbounds is None and dbounds != (None,None):
    664                 for varval in self._varval.itervalues():
     661                for varval in self._data.itervalues():
    665662                    if not dbounds[0] is None:
    666663                        if varval.lb is None or                     \
     
    678675            default_value = self._attr_declarations[attr_name][0]
    679676            suffix_dict = {}
    680             for key in self._varval:
     677            for key in self._data:
    681678                suffix_dict[key]=default_value
    682679            self._attr_values[attr_name] = suffix_dict
     
    699696                print >>ostream, str(idx.name)+", ",
    700697            print ""
    701         if None in self._varval:
     698        if None in self._data:
    702699            print >>ostream, "\tInitial Value : Lower Bound : Upper Bound : "  \
    703700                             "Current Value: Fixed: Status"
    704701            lb_value = None
    705             if self._varval[None].lb is not None:
    706                 lb_value = self._varval[None].lb()
     702            if self._data[None].lb is not None:
     703                lb_value = self._data[None].lb()
    707704            ub_value = None
    708             if self._varval[None].ub is not None:
    709                 ub_value = self._varval[None].ub()
     705            if self._data[None].ub is not None:
     706                ub_value = self._data[None].ub()
    710707
    711708            print >>ostream, "\t %s : %s : %s : %s : %s : %s" % (
    712               str(self._varval[None].initial),
     709              str(self._data[None].initial),
    713710              str(lb_value),
    714711              str(ub_value),
    715               str(self._varval[None].value),
    716               str(self._varval[None].fixed),
    717               str(self._varval[None].status)
     712              str(self._data[None].value),
     713              str(self._data[None].fixed),
     714              str(self._data[None].status)
    718715            )
    719716        else:
    720717            print >>ostream, "\tKey : Initial Value : Lower Bound : "          \
    721718                             "Upper Bound : Current Value: Fixed: Status"
    722             tmp=self._varval.keys()
     719            tmp=self._data.keys()
    723720            tmp.sort()
    724721            for key in tmp:
    725                 initial_val = self._varval[key].initial
     722                initial_val = self._data[key].initial
    726723                lb_value = None
    727                 if self._varval[key].lb is not None:
    728                     lb_value = self._varval[key].lb()
     724                if self._data[key].lb is not None:
     725                    lb_value = self._data[key].lb()
    729726                ub_value = None
    730                 if self._varval[key].ub is not None:
    731                     ub_value = self._varval[key].ub()
     727                if self._data[key].ub is not None:
     728                    ub_value = self._data[key].ub()
    732729
    733730                print >>ostream, "\t%s : %s : %s : %s : %s : %s : %s" % (
     
    736733                  str(lb_value),
    737734                  str(ub_value),
    738                   str(value(self._varval[key].value)),
    739                   str(value(self._varval[key].fixed)),
    740                   str(self._varval[key].status)
     735                  str(value(self._data[key].value)),
     736                  str(value(self._data[key].fixed)),
     737                  str(self._data[key].status)
    741738                )
    742739
     
    748745        print >>ostream, "  Size="+str(len(self)),
    749746        print >>ostream, "Domain="+self.domain.name
    750         if None in self._varval:
     747        if None in self._data:
    751748            print >>ostream, "%s  Value=%s" % (
    752749              prefix,
    753               pyutilib.misc.format_io(self._varval[None].value)
     750              pyutilib.misc.format_io(self._data[None].value)
    754751            )
    755752        else:
    756             for key in self._varval:
    757                 val = self._varval[key].value
     753            for key in self._data:
     754                val = self._data[key].value
    758755                print >>ostream, prefix+"  "+str(key)+" : "+str(val)
    759756
     
    775772        #
    776773        # add to self._attr_values
    777         if len(self._varval) > 0:
     774        if len(self._data) > 0:
    778775            suffix_dict = {}
    779             for key in self._varval:
     776            for key in self._data:
    780777                suffix_dict[key]=default
    781778            self._attr_values[name] = suffix_dict
     
    800797                            self)
    801798        Var.__init__(self, *args, **kwd)
    802         self._varval[None] = self
    803         self._varval[None].index = None
     799        self._data[None] = self
     800        self._data[None].index = None
    804801
    805802    def __call__(self, exception=True):
    806         if None in self._varval:
    807             return self._varval[None].value
     803        if None in self._data:
     804            return self._data[None].value
    808805        return None
    809806
     
    823820            setattr(self, slot_name, value)
    824821
    825         self._varval[None].component = weakref.ref(self)
     822        self._data[None].component = weakref.ref(self)
    826823        # this is hackish, in that it replicates code from the base Component setstate method - revisit at some point.
    827824        if '_parent' in self.__dict__.keys() and self._parent is not None and type(self._parent) != weakref.ref:
     
    860857        Var.construct(self, data)
    861858
    862         for (ndx, var) in self._varval.iteritems():
     859        for (ndx, var) in self._data.iteritems():
    863860            var._tighten_bounds()
    864861
  • coopr.pyomo/trunk/coopr/pyomo/io/cpxlp.py

    r5698 r5768  
    663663                    elif isinstance(var_value.domain, BooleanSet): nbv += 1
    664664
    665                 for index in sorted(var._varval.keys()):
    666 
    667                     this_varval = var[index]
    668 
    669                     if (not this_varval.active) or (this_varval.status is not VarStatus.used):
     665                for index in sorted(var._data.keys()):
     666
     667                    this_data = var[index]
     668
     669                    if (not this_data.active) or (this_data.status is not VarStatus.used):
    670670                        continue
    671671
     
    675675                    # (which we would argue is more rational).
    676676                    print >>OUTPUT,"   ",
    677                     if this_varval.lb is not None:
    678                         print >>OUTPUT, value(this_varval.lb()), "<= ",
     677                    if this_data.lb is not None:
     678                        print >>OUTPUT, value(this_data.lb()), "<= ",
    679679                    else:
    680680                        print >>OUTPUT, " -inf <= ",
    681                     name_to_output = object_symbol_dictionary[id(this_varval)]
     681                    name_to_output = object_symbol_dictionary[id(this_data)]
    682682                    if name_to_output == "e":
    683683                        msg = 'Attempting to write variable with name' \
     
    688688                        raise ValueError, msg
    689689                    print >>OUTPUT, name_to_output,
    690                     if this_varval.ub is not None:
    691                         print >>OUTPUT, " <=", value(this_varval.ub())
     690                    if this_data.ub is not None:
     691                        print >>OUTPUT, " <=", value(this_data.ub())
    692692                    else:
    693693                        print >>OUTPUT, " <= +inf"
     
    702702                    var = active_variables[variable_name]
    703703                    for index in sorted(var.integer_keys()):
    704                         this_varvalue = var[index]
    705                         if (not this_varvalue.active) or (this_varvalue.status is not VarStatus.used):
     704                        this_data = var[index]
     705                        if (not this_data.active) or (this_data.status is not VarStatus.used):
    706706                            continue
    707                         var_name = object_symbol_dictionary[id(this_varvalue)]
     707                        var_name = object_symbol_dictionary[id(this_data)]
    708708                        print >>OUTPUT, ' ', var_name
    709709
     
    717717                    var = active_variables[variable_name]
    718718                    for index in sorted(var.binary_keys()):
    719                         this_varvalue = var[index]
    720                         if (not this_varvalue.active) or (this_varvalue.status is not VarStatus.used):
     719                        this_data = var[index]
     720                        if (not this_data.active) or (this_data.status is not VarStatus.used):
    721721                            continue
    722                         var_name = object_symbol_dictionary[id(this_varvalue)]
     722                        var_name = object_symbol_dictionary[id(this_data)]
    723723                        print >>OUTPUT, ' ', var_name
    724724
  • coopr.pyomo/trunk/coopr/pyomo/io/problem_utils.py

    r5633 r5768  
    7474                        if v != "0":
    7575                            raise ValueError, "Two variables in ProductExpression:",e
    76                         e._varval[None]._sno = 0
     76                        e._data[None]._sno = 0
    7777                    elif isinstance(e,_VarData):
    7878                        if v != "0":
     
    104104        # forcing the "_sno" on the variable value explicitly.
    105105        elif isinstance(exp,Var):
    106             exp._varval[None]._sno = 0
     106            exp._data[None]._sno = 0
    107107        #
    108108        # If not a constant, then this is an error
     
    145145                        if v != "0":
    146146                            raise ValueError, "ERROR: two variables in ProductExpression:",e
    147                         v = self._name_fix(e._varval[None].name)
    148                         ve = e._varval[None]
     147                        v = self._name_fix(e._data[None].name)
     148                        ve = e._data[None]
    149149                    elif isinstance(e,_VarData):
    150150                        if v != "0":
     
    216216        #
    217217        for var in Vars.values():
    218             for V in var._varval.keys():
    219                 var._varval[V]._sno = -1
     218            for V in var._data.keys():
     219                var._data[V]._sno = -1
    220220        #
    221221        # Call _Collect1 to find the variables that are used in
     
    255255        sno = 0
    256256        for var in Vars.values():
    257             Vv = var._varval
     257            Vv = var._data
    258258            for V in Vv:
    259259                if Vv[V]._sno != -1:
  • coopr.pyomo/trunk/coopr/pyomo/preprocess/identify_vars.py

    r5757 r5768  
    243243        for block in all_blocks:
    244244            for var in block.active_components(Var).itervalues():
    245                 for var_value in var._varval.itervalues():
     245                for var_value in var._data.itervalues():
    246246                    var_value.status = VarStatus.unused
    247247
  • coopr.pyomo/trunk/coopr/pyomo/transform/eliminate_fixed_vars.py

    r5757 r5768  
    5656                M.statistics.number_of_variables -= 1
    5757                del M._label_var_map[ var.label ]
    58                 del var.component()._varval[ var.index ]
     58                del var.component()._data[ var.index ]
    5959            else:
    6060                M._var[ ctr ] = var
Note: See TracChangeset for help on using the changeset viewer.