Changeset 1994


Ignore:
Timestamp:
12/13/09 11:01:57 (4 years ago)
Author:
wehart
Message:

Initial setup of the PyomoModel?._name_conmap data structure.
I've set this up to load data, but it currently does not correctly load
data for range constraints.

Misc rework of tests, segregating model/var/objective/constraint tests.

Added some tests for activation/deactivation of constraints. This
required some changes to the 'display()' methods in Pyomo, to
hide constraints that are deactivated.

Location:
coopr.pyomo/trunk/coopr/pyomo
Files:
5 added
5 edited

Legend:

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

    r1992 r1994  
    3030from rangeset import RangeSet 
    3131from var import Var 
    32 from constraint import Objective, Constraint 
     32from constraint import Objective, Constraint, ConstraintData 
    3333from param import Param 
    3434 
     
    5555        # 
    5656        self._declarations=[] 
    57         # the _name_varmap is assigned when the problem definition 
     57        # the _name_varmap and _name_conmap dictionarys are assigned when  
     58        # the problem definition 
    5859        # file is written, i.e., via the write() command. intent 
    5960        # is to map names that will be coming back from a solver 
    6061        # into Pyomo variables. Values are of type _VarValue. 
    6162        self._name_varmap={} 
     63        self._name_conmap={} 
    6264        self.name="unknown" 
    6365        self.tmpctr=0 
    6466        self._varctr=0 
    65         #self._varmap={} 
    6667        self._presolvers = ["simple_presolver"] 
    6768        # 
     
    8081        raise KeyError, "Unknown component type: %s" % str(ctype) 
    8182 
    82              
    8383 
    8484    def active_components(self, _ctype=None): 
     
    9898        if not _ctype is None: 
    9999            return tmp[_ctype] 
     100        print "ACTIVE",tmp 
    100101        return tmp 
    101102 
     
    312313        Load a solution. 
    313314        """ 
     315        # 
     316        # Load variable data 
     317        # 
    314318        for name in soln.variable: 
    315319          # 
     
    331335                raise TypeError, "Variable '"+name+"' in model '"+self.name+"' is currently fixed - new value is not expected in solution" 
    332336 
    333              # the value is always present in any legal solution. 
    334              self._name_varmap[name].value = soln.variable[name].value 
    335  
    336              # the reduced-cost might be present, depending on what the solver is reporting. 
    337              if hasattr(soln.variable[name],"rc"): 
    338                 self._name_varmap[name].rc = soln.variable[name].rc 
     337             #print "HERE",soln.variable[name].keys() 
     338             for _key in soln.variable[name].keys(): 
     339                key = _key[0].lower() + _key[1:]  
     340                if key == 'value': 
     341                    self._name_varmap[name].value = soln.variable[name].value 
     342                elif not key == 'id': 
     343                    setattr(self._name_varmap[name], key, getattr(soln.variable[name], _key)) 
     344        # 
     345        # Load constraint data 
     346        # 
     347        for name in soln.constraint: 
     348             # 
     349             # This is a hack 
     350             # 
     351             if name.endswith('ONE_VAR_CONSTANT'): 
     352                continue 
     353             if symbol_map is not None: 
     354                name = symbol_map[name] 
     355             # 
     356             # This is a hack.  Is there a standard convention for constraint 
     357             # names that we can apply to all data formats? 
     358             # 
     359             if name[0:2] == 'c_': 
     360                _name = name[4:-1] 
     361             #print "HERE",_name 
     362             if _name not in self._name_conmap: 
     363                names="" 
     364                raise KeyError, "Constraint name '"+name+"' is not in model "+self.name+".  Valid constraint names: "+str(self._name_conmap.keys()) 
     365             if not isinstance(self._name_conmap[_name],ConstraintData): 
     366                raise TypeError, "Constraint '"+name+"' in model '"+self.name+"' is type "+str(type(self._name_conmap[_name])) 
     367 
     368             #print "HERE",soln.constraint[name].keys() 
     369             for _key in soln.constraint[name].keys(): 
     370                key = _key[0].lower() + _key[1:]  
     371                if key == 'value': 
     372                    self._name_conmap[name].value = soln.constraint[name].value 
     373                elif not key == 'id': 
     374                    setattr(self._name_conmap[_name], key, getattr(soln.constraint[name], _key)) 
    339375 
    340376    def write(self,filename=None,format=ProblemFormat.cpxlp): 
     
    399435 
    400436 
    401     def display(self,filename=None, ostream=None): 
     437    def display(self, filename=None, ostream=None): 
    402438        """ 
    403439        Print the Pyomo model in a verbose format. 
     
    413449        print >>ostream, "" 
    414450        print >>ostream, "  Variables:" 
    415         if len(self._component[Var]) == 0: 
    416            print >>ostream, "    None" 
     451        VAR = self.active_components(Var) 
     452        if len(VAR) == 0: 
     453            print >>ostream, "    None" 
    417454        else: 
    418            for ndx in self._component[Var]: 
    419              self._component[Var][ndx].display(prefix="    ",ostream=ostream) 
     455            for ndx in VAR: 
     456                VAR[ndx].display(prefix="    ",ostream=ostream) 
    420457        print >>ostream, "" 
    421458        print >>ostream, "  Objectives:" 
    422         if len(self._component[Objective]) == 0: 
    423            print >>ostream, "    None" 
     459        OBJ = self.active_components(Objective) 
     460        if len(OBJ) == 0: 
     461            print >>ostream, "    None" 
    424462        else: 
    425            for ndx in self._component[Objective]: 
    426              self._component[Objective][ndx].display(prefix="    ",ostream=ostream) 
     463            for ndx in OBJ: 
     464                OBJ[ndx].display(prefix="    ",ostream=ostream) 
    427465        print >>ostream, "" 
     466        CON = self.active_components(Constraint) 
    428467        print >>ostream, "  Constraints:" 
    429         if len(self._component[Constraint]) == 0: 
    430            print >>ostream, "    None" 
     468        if len(CON) == 0: 
     469            print >>ostream, "    None" 
    431470        else: 
    432            for ndx in self._component[Constraint]: 
    433              self._component[Constraint][ndx].display(prefix="    ",ostream=ostream) 
    434  
     471            for ndx in CON: 
     472                CON[ndx].display(prefix="    ",ostream=ostream) 
     473 
  • coopr.pyomo/trunk/coopr/pyomo/base/component.py

    r1992 r1994  
    77 
    88    def activate(self): 
    9         self._active=True 
     9        self.active=True 
    1010 
    1111    def deactivate(self): 
    12         self._active=False 
     12        self.active=False 
    1313 
    1414    def type(self): 
  • coopr.pyomo/trunk/coopr/pyomo/base/constraint.py

    r1993 r1994  
    178178        else: 
    179179           for key in self._data: 
     180             if not self._data[key].active: 
     181                continue 
    180182             val = self._data[key].expr(exception=False) 
    181183             print >>ostream, prefix+"  "+str(key)+" : "+str(val) 
     
    548550           print >>ostream, prefix+"  Value="+pyutilib.misc.format_io(self._data[None].body()) 
    549551        else: 
    550            print >>ostream, prefix+"        \tLower\tBody\t\tUpper" 
     552           flag=True 
    551553           for key in self._data: 
     554             if not self._data[key].active: 
     555                continue 
     556             if flag: 
     557                print >>ostream, prefix+"        \tLower\tBody\t\tUpper" 
     558                flag=False 
    552559             if self._data[key].lower is not None: 
    553560                lval = str(self._data[key].lower()) 
     
    560567                uval = "Infinity" 
    561568             print >>ostream, prefix+"  "+str(key)+" :\t"+lval+"\t"+val+"\t"+uval 
     569           if flag: 
     570                print >>ostream, prefix+"  None active" 
    562571 
    563572 
  • coopr.pyomo/trunk/coopr/pyomo/presolve/generic_varlabels.py

    r1992 r1994  
    99#  _________________________________________________________________________ 
    1010 
    11 from coopr.pyomo.base import IPyomoPresolver, IPyomoPresolveAction, Var 
     11from coopr.pyomo.base import IPyomoPresolver, IPyomoPresolveAction, Var, Constraint 
    1212import pyutilib.plugin.core 
    1313 
     
    6060                var._varval[V].label = self._name_fix( var._varval[V].name ) 
    6161                model._name_varmap[ var._varval[V].label ] = var._varval[V] 
    62         for id in model._con: 
    63             model._con[id].label = self._name_fix( model._con[id].name ) 
     62        Cons = model.active_components(Constraint) 
     63        for con in Cons.values(): 
     64            for C in con._data: 
     65                con._data[C].label = self._name_fix( con._data[C].name ) 
     66                model._name_conmap[ con._data[C].label ] = con._data[C] 
    6467        return model 
    6568             
  • coopr.pyomo/trunk/coopr/pyomo/tests/unit/test_model.py

    r1992 r1994  
    22# Unit Tests for Elements of a Model 
    33# 
    4 # TestSimpleVar                Class for testing single variables 
    5 # TestArrayVar                Class for testing array of variables 
    6 # TestSimpleObj                Class for testing single objective 
    7 # TestArrayObj                Class for testing array of objective 
    8 # TestSimpleCon                Class for testing single constraint 
    9 # TestArrayCon                Class for testing array of constraint 
    10 # TestModel             Class to test the Model class 
     4# Test             Class to test the Model class 
    115# 
    126 
     
    3428 
    3529 
    36 class TestSimpleVar(PyomoModel): 
     30class Test(PyomoModel): 
    3731 
    3832    def setUp(self): 
     
    4337 
    4438    def tearDown(self): 
    45         pass 
    46  
    47     def test_fixed_attr(self): 
    48         """Test fixed attribute""" 
    49         self.model.x = Var() 
    50         self.instance = self.model.create() 
    51         self.instance.x.fixed = True 
    52         self.failUnlessEqual(self.instance.x.fixed, True) 
    53  
    54     def test_value_attr(self): 
    55         """Test value attribute""" 
    56         self.model.x = Var() 
    57         self.instance = self.model.create() 
    58         self.instance.x.value = 3.5 
    59         self.failUnlessEqual(self.instance.x.value, 3.5) 
    60  
    61     def test_initial_attr(self): 
    62         """Test initial attribute""" 
    63         self.model.x = Var() 
    64         self.instance = self.model.create() 
    65         self.instance.x.initial = 3.5 
    66         self.failUnlessEqual(self.instance.x.initial, 3.5) 
    67  
    68     def test_domain_attr(self): 
    69         """Test domain attribute""" 
    70         self.model.x = Var() 
    71         self.instance = self.model.create() 
    72         self.instance.x.domain = Integers 
    73         self.failUnlessEqual(type(self.instance.x.domain), IntegerSet) 
    74  
    75     def test_name_attr(self): 
    76         """Test name attribute""" 
    77         # 
    78         # A user would never need to do this, but this  
    79         # attribute is needed within Pyomo 
    80         # 
    81         self.model.x = Var() 
    82         self.model.x.name = "foo" 
    83         self.failUnlessEqual(self.model.x.name, "foo") 
    84  
    85     def test_lb_attr1(self): 
    86         """Test lb attribute""" 
    87         self.model.x = Var() 
    88         self.instance = self.model.create() 
    89         self.instance.x.setlb(-1.0) 
    90         self.failUnlessEqual(self.instance.x.lb(), -1.0) 
    91  
    92     def test_lb_attr2(self): 
    93         """Test lb attribute""" 
    94         self.model.x = Var(within=NonNegativeReals, bounds=(-1,2)) 
    95         self.instance = self.model.create() 
    96         self.failUnlessEqual(self.instance.x.lb(), 0.0) 
    97         self.failUnlessEqual(self.instance.x.ub(), 2.0) 
    98  
    99     def test_ub_attr1(self): 
    100         """Test ub attribute""" 
    101         self.model.x = Var() 
    102         self.instance = self.model.create() 
    103         self.instance.x.setub(1.0) 
    104         self.failUnlessEqual(self.instance.x.ub(), 1.0) 
    105  
    106     def test_ub_attr2(self): 
    107         """Test ub attribute""" 
    108         self.model.x = Var(within=NonPositiveReals, bounds=(-2,1)) 
    109         self.instance = self.model.create() 
    110         self.failUnlessEqual(self.instance.x.lb(), -2.0) 
    111         self.failUnlessEqual(self.instance.x.ub(), 0.0) 
    112  
    113     def test_within_option(self): 
    114         """Test within option""" 
    115         self.model.x = Var(within=Integers) 
    116         self.failUnlessEqual(type(self.model.x.domain), IntegerSet) 
    117  
    118     def test_initialize_option(self): 
    119         """Test initialize option""" 
    120         self.model.x = Var(initialize=1.3) 
    121         self.instance = self.model.create() 
    122         self.failUnlessEqual(self.instance.x.initial, 1.3) 
    123  
    124     def test_bounds_option1(self): 
    125         """Test bounds option""" 
    126         def x_bounds(model): 
    127           return (-1.0,1.0) 
    128         self.model.x = Var(bounds=x_bounds) 
    129         self.instance = self.model.create() 
    130         self.failUnlessEqual(self.instance.x.lb(), -1.0) 
    131         self.failUnlessEqual(self.instance.x.ub(), 1.0) 
    132  
    133     def test_bounds_option2(self): 
    134         """Test bounds option""" 
    135         self.model.x = Var(bounds=(-1.0,1.0)) 
    136         self.instance = self.model.create() 
    137         self.failUnlessEqual(self.instance.x.lb(), -1.0) 
    138         self.failUnlessEqual(self.instance.x.ub(), 1.0) 
    139  
    140     def test_rule_option(self): 
    141         """Test rule option""" 
    142         def x_init(model): 
    143           return 1.3 
    144         self.model.x = Var(initialize=x_init) 
    145         self.instance = self.model.create() 
    146         self.failUnlessEqual(self.instance.x.value, None) 
    147         self.failUnlessEqual(self.instance.x.initial, 1.3) 
    148  
    149     def test_reset(self): 
    150         """Test reset method""" 
    151         self.model.x = Var(initialize=3) 
    152         self.instance = self.model.create() 
    153         self.failUnlessEqual(self.instance.x.initial,3) 
    154         self.failUnlessEqual(self.instance.x.value,None) 
    155         self.instance.x.reset() 
    156         self.failUnlessEqual(self.instance.x.initial,3) 
    157         self.failUnlessEqual(self.instance.x.initial,3) 
    158  
    159     def test_dim(self): 
    160         """Test dim method""" 
    161         self.model.x = Var() 
    162         self.instance = self.model.create() 
    163         self.failUnlessEqual(self.instance.x.dim(),0) 
    164  
    165     def test_keys(self): 
    166         """Test keys method""" 
    167         self.model.x = Var() 
    168         self.instance = self.model.create() 
    169         self.failUnlessEqual(self.instance.x.keys(),[None]) 
    170  
    171     def test_len(self): 
    172         """Test len method""" 
    173         self.model.x = Var() 
    174         self.instance = self.model.create() 
    175         self.failUnlessEqual(len(self.instance.x),1) 
    176  
    177     def test_simplify(self): 
    178         """Test simplify method""" 
    179         self.model.x = Var() 
    180         self.failUnlessEqual(type(self.model.x.simplify(self.model)),_VarElement) 
    181  
    182     def test_value(self): 
    183         """Check the value of the variable""" 
    184         self.model.x = Var(initialize=3.3) 
    185         self.instance = self.model.create() 
    186         tmp = value(self.instance.x.initial) 
    187         self.failUnlessEqual( type(tmp), float) 
    188         self.failUnlessEqual( tmp, 3.3 ) 
    189         tmp = float(self.instance.x.initial) 
    190         self.failUnlessEqual( type(tmp), float) 
    191         self.failUnlessEqual( tmp, 3.3 ) 
    192         tmp = int(self.instance.x.initial) 
    193         self.failUnlessEqual( type(tmp), int) 
    194         self.failUnlessEqual( tmp, 3 ) 
    195  
    196  
    197 class TestArrayVar(TestSimpleVar): 
    198  
    199     def setUp(self): 
    200         # 
    201         # Create Model 
    202         # 
    203         PyomoModel.setUp(self) 
    204         self.model.A = Set(initialize=[1,2]) 
    205  
    206     def test_fixed_attr(self): 
    207         """Test fixed attribute""" 
    208         self.model.x = Var(self.model.A) 
    209         self.model.y = Var(self.model.A) 
    210         self.instance = self.model.create() 
    211         self.instance.x.fixed = True 
    212         #try: 
    213           #self.instance.x.fixed 
    214         #except AttributeError: 
    215           #pass 
    216         #else: 
    217           #self.fail("test_fixed_attr") 
    218         self.failUnlessEqual(self.instance.x[1].fixed, False) 
    219         self.instance.y[1].fixed=True 
    220         self.failUnlessEqual(self.instance.y[1].fixed, True) 
    221  
    222     def test_value_attr(self): 
    223         """Test value attribute""" 
    224         self.model.x = Var(self.model.A) 
    225         self.model.y = Var(self.model.A) 
    226         self.instance = self.model.create() 
    227         try: 
    228             self.instance.x = 3.5 
    229             self.fail("Expected ValueError") 
    230         except ValueError: 
    231             pass 
    232         self.instance.y[1] = 3.5 
    233         self.failUnlessEqual(self.instance.y[1], 3.5) 
    234  
    235     #def test_initial_attr(self): 
    236         #"""Test initial attribute""" 
    237         #self.model.x = Var(self.model.A) 
    238         #self.instance = self.model.create() 
    239         #self.instance.x.initial = 3.5 
    240         #self.failUnlessEqual(self.instance.x[1].initial, 3.5) 
    241  
    242     #def test_lb_attr(self): 
    243         #"""Test lb attribute""" 
    244         #self.model.x = Var(self.model.A) 
    245         #self.instance = self.model.create() 
    246         #self.instance.x.setlb(-1.0) 
    247         #self.failUnlessEqual(self.instance.x[1].lb(), -1.0) 
    248  
    249     #def test_ub_attr(self): 
    250         #"""Test ub attribute""" 
    251         #self.model.x = Var(self.model.A) 
    252         #self.instance = self.model.create() 
    253         #self.instance.x.setub(1.0) 
    254         #self.failUnlessEqual(self.instance.x[1].ub(), 1.0) 
    255  
    256     def test_initialize_option(self): 
    257         """Test initialize option""" 
    258         self.model.x = Var(self.model.A,initialize={1:1.3,2:2.3}) 
    259         self.instance = self.model.create() 
    260         self.failUnlessEqual(self.instance.x[1], 1.3) 
    261         self.failUnlessEqual(self.instance.x[2], 2.3) 
    262  
    263     def test_bounds_option1(self): 
    264         """Test bounds option""" 
    265         def x_bounds(i,model): 
    266           return (-1.0,1.0) 
    267         self.model.x = Var(self.model.A, bounds=x_bounds) 
    268         self.instance = self.model.create() 
    269         self.failUnlessEqual(self.instance.x[1].lb(), -1.0) 
    270         self.failUnlessEqual(self.instance.x[1].ub(), 1.0) 
    271  
    272     def test_bounds_option2(self): 
    273         """Test bounds option""" 
    274         self.model.x = Var(self.model.A, bounds=(-1.0,1.0)) 
    275         self.instance = self.model.create() 
    276         self.failUnlessEqual(self.instance.x[1].lb(), -1.0) 
    277         self.failUnlessEqual(self.instance.x[1].ub(), 1.0) 
    278  
    279     def test_rule_option(self): 
    280         """Test rule option""" 
    281         def x_init(i,model): 
    282           return 1.3 
    283         self.model.x = Var(self.model.A, initialize=x_init) 
    284         self.instance = self.model.create() 
    285         self.failUnlessEqual(self.instance.x[1].initial, 1.3) 
    286  
    287     def test_reset(self): 
    288         """Test reset method""" 
    289         self.model.x = Var(self.model.A,initialize=3) 
    290         self.instance = self.model.create() 
    291         self.failUnlessEqual(self.instance.x[1].initial,3) 
    292         self.failUnlessEqual(self.instance.x[1].value,None) 
    293         self.instance.x.reset() 
    294         self.failUnlessEqual(self.instance.x[1].initial,3) 
    295         self.failUnlessEqual(self.instance.x[1].initial,3) 
    296  
    297     def test_dim(self): 
    298         """Test dim method""" 
    299         self.model.x = Var(self.model.A) 
    300         self.instance = self.model.create() 
    301         self.failUnlessEqual(self.instance.x.dim(),1) 
    302  
    303     def test_keys(self): 
    304         """Test keys method""" 
    305         self.model.x = Var(self.model.A) 
    306         self.instance = self.model.create() 
    307         self.failUnlessEqual(self.instance.x.keys(),[1,2]) 
    308  
    309     def test_len(self): 
    310         """Test len method""" 
    311         self.model.x = Var(self.model.A) 
    312         self.instance = self.model.create() 
    313         self.failUnlessEqual(len(self.instance.x),2) 
    314  
    315     def test_value(self): 
    316         """Check the value of the variable""" 
    317         self.model.x = Var(self.model.A,initialize=3.3) 
    318         self.instance = self.model.create() 
    319         tmp = value(self.instance.x[1].initial) 
    320         self.failUnlessEqual( type(tmp), float) 
    321         self.failUnlessEqual( tmp, 3.3 ) 
    322         tmp = float(self.instance.x[1].initial) 
    323         self.failUnlessEqual( type(tmp), float) 
    324         self.failUnlessEqual( tmp, 3.3 ) 
    325         tmp = int(self.instance.x[1].initial) 
    326         self.failUnlessEqual( type(tmp), int) 
    327         self.failUnlessEqual( tmp, 3 ) 
    328  
    329  
    330 class Test2DArrayVar(TestSimpleVar): 
    331  
    332     def setUp(self): 
    333         # 
    334         # Create Model 
    335         # 
    336         PyomoModel.setUp(self) 
    337         self.model.A = Set(initialize=[1,2]) 
    338  
    339     def test_fixed_attr(self): 
    340         """Test fixed attribute""" 
    341         self.model.x = Var(self.model.A,self.model.A) 
    342         self.model.y = Var(self.model.A,self.model.A) 
    343         self.instance = self.model.create() 
    344         self.instance.x.fixed = True 
    345         #try: 
    346           #self.instance.x.fixed 
    347         #except AttributeError: 
    348           #pass 
    349         #else: 
    350           #self.fail("test_fixed_attr") 
    351         self.failUnlessEqual(self.instance.x[1,2].fixed, False) 
    352         self.instance.y[1,2].fixed=True 
    353         self.failUnlessEqual(self.instance.y[1,2].fixed, True) 
    354  
    355     def test_value_attr(self): 
    356         """Test value attribute""" 
    357         self.model.x = Var(self.model.A,self.model.A) 
    358         self.model.y = Var(self.model.A,self.model.A) 
    359         self.instance = self.model.create() 
    360         try: 
    361             self.instance.x = 3.5 
    362             self.fail("Expected ValueError") 
    363         except ValueError: 
    364             pass 
    365         self.instance.y[1,2] = 3.5 
    366         self.failUnlessEqual(self.instance.y[1,2], 3.5) 
    367  
    368     #def test_initial_attr(self): 
    369         #"""Test initial attribute""" 
    370         #self.model.x = Var(self.model.A,self.model.A) 
    371         #self.instance = self.model.create() 
    372         #self.instance.x.initial = 3.5 
    373         #self.failUnlessEqual(self.instance.x[1,1].initial, 3.5) 
    374  
    375     #def test_lb_attr(self): 
    376         #"""Test lb attribute""" 
    377         #self.model.x = Var(self.model.A,self.model.A) 
    378         #self.instance = self.model.create() 
    379         #self.instance.x.setlb(-1.0) 
    380         #self.failUnlessEqual(self.instance.x[2,1].lb(), -1.0) 
    381  
    382     #def test_ub_attr(self): 
    383         #"""Test ub attribute""" 
    384         #self.model.x = Var(self.model.A,self.model.A) 
    385         #self.instance = self.model.create() 
    386         #self.instance.x.setub(1.0) 
    387         #self.failUnlessEqual(self.instance.x[2,1].ub(), 1.0) 
    388  
    389     def test_initialize_option(self): 
    390         """Test initialize option""" 
    391         self.model.x = Var(self.model.A,self.model.A,initialize={(1,1):1.3,(2,2):2.3}) 
    392         self.instance = self.model.create() 
    393         self.failUnlessEqual(self.instance.x[1,1], 1.3) 
    394         self.failUnlessEqual(self.instance.x[2,2], 2.3) 
    395         try: 
    396             value(self.instance.x[1,2]) 
    397             self.fail("Expected KeyError") 
    398         except KeyError: 
    399             pass 
    400  
    401     def test_bounds_option1(self): 
    402         """Test bounds option""" 
    403         def x_bounds(i,j,model): 
    404           return (-1.0*(i+j),1.0*(i+j)) 
    405         self.model.x = Var(self.model.A, self.model.A, bounds=x_bounds) 
    406         self.instance = self.model.create() 
    407         self.failUnlessEqual(self.instance.x[1,1].lb(), -2.0) 
    408         self.failUnlessEqual(self.instance.x[1,2].ub(), 3.0) 
    409  
    410     def test_bounds_option2(self): 
    411         """Test bounds option""" 
    412         self.model.x = Var(self.model.A, self.model.A, bounds=(-1.0,1.0)) 
    413         self.instance = self.model.create() 
    414         self.failUnlessEqual(self.instance.x[1,1].lb(), -1.0) 
    415         self.failUnlessEqual(self.instance.x[1,1].ub(), 1.0) 
    416  
    417     def test_rule_option(self): 
    418         """Test rule option""" 
    419         def x_init(i,j,model): 
    420           return 1.3 
    421         self.model.x = Var(self.model.A, self.model.A, initialize=x_init) 
    422         self.instance = self.model.create() 
    423         self.failUnlessEqual(self.instance.x[1,2].initial, 1.3) 
    424  
    425     def test_reset(self): 
    426         """Test reset method""" 
    427         self.model.x = Var(self.model.A,self.model.A, initialize=3) 
    428         self.instance = self.model.create() 
    429         self.failUnlessEqual(self.instance.x[1,1].initial,3) 
    430         self.failUnlessEqual(self.instance.x[1,1].value,None) 
    431         self.instance.x.reset() 
    432         self.failUnlessEqual(self.instance.x[1,1].initial,3) 
    433         self.failUnlessEqual(self.instance.x[1,1].initial,3) 
    434  
    435     def test_dim(self): 
    436         """Test dim method""" 
    437         self.model.x = Var(self.model.A,self.model.A) 
    438         self.instance = self.model.create() 
    439         self.failUnlessEqual(self.instance.x.dim(),2) 
    440  
    441     def test_keys(self): 
    442         """Test keys method""" 
    443         self.model.x = Var(self.model.A,self.model.A) 
    444         self.instance = self.model.create() 
    445         ans = [(1,1),(1,2),(2,1),(2,2)] 
    446         self.failUnlessEqual(self.instance.x.keys().sort(),ans.sort()) 
    447  
    448     def test_len(self): 
    449         """Test len method""" 
    450         self.model.x = Var(self.model.A,self.model.A) 
    451         self.instance = self.model.create() 
    452         self.failUnlessEqual(len(self.instance.x),4) 
    453  
    454     def test_value(self): 
    455         """Check the value of the variable""" 
    456         self.model.x = Var(self.model.A,self.model.A,initialize=3.3) 
    457         self.instance = self.model.create() 
    458         tmp = value(self.instance.x[1,1].initial) 
    459         self.failUnlessEqual( type(tmp), float) 
    460         self.failUnlessEqual( tmp, 3.3 ) 
    461         tmp = float(self.instance.x[1,1].initial) 
    462         self.failUnlessEqual( type(tmp), float) 
    463         self.failUnlessEqual( tmp, 3.3 ) 
    464         tmp = int(self.instance.x[1,1].initial) 
    465         self.failUnlessEqual( type(tmp), int) 
    466         self.failUnlessEqual( tmp, 3 ) 
    467  
    468  
    469 class 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) 
    489  
    490  
    491 class TestSimpleObj(PyomoModel): 
    492  
    493     def setUp(self): 
    494         # 
    495         # Create Model 
    496         # 
    497         PyomoModel.setUp(self) 
    498  
    499     def tearDown(self): 
    500         pass 
    501  
    502     def test_rule_option(self): 
    503         """Test rule option""" 
    504         def f(model): 
    505           ans=0 
    506           for i in model.x.keys(): 
    507             ans = ans + model.x[i] 
    508           return ans 
    509         self.model.x = Var(RangeSet(1,4),initialize=2) 
    510         self.model.obj = Objective(rule=f) 
    511         self.instance = self.model.create() 
    512         try: 
    513           self.failUnlessEqual(self.instance.obj(), 8) 
    514         except ValueError: 
    515           pass 
    516         else: 
    517           self.fail("test_rule_option") 
    518         self.instance.x.reset() 
    519         self.failUnlessEqual(self.instance.obj(), 8) 
    520         self.failUnlessEqual(value(self.instance.obj), 8) 
    521  
    522     def test_sense_option(self): 
    523         """Test sense option""" 
    524         def rule(model): 
    525             return 1.0 
    526         self.model.obj = Objective(sense=maximize, rule=rule) 
    527         self.instance = self.model.create() 
    528         self.failUnlessEqual(self.instance.obj.sense, maximize) 
    529  
    530     def test_dim(self): 
    531         """Test dim method""" 
    532         def rule(model): 
    533             return 1 
    534         self.model.obj = Objective(rule=rule) 
    535         self.instance = self.model.create() 
    536         self.failUnlessEqual(self.instance.obj.dim(),0) 
    537  
    538     def test_keys(self): 
    539         """Test keys method""" 
    540         def rule(model): 
    541             return 1 
    542         self.model.obj = Objective(rule=rule) 
    543         self.instance = self.model.create() 
    544         self.failUnlessEqual(self.instance.obj.keys(),[None]) 
    545  
    546     def test_len(self): 
    547         """Test len method""" 
    548         def rule(model): 
    549             return 1.0 
    550         self.model.obj = Objective(rule=rule) 
    551         self.instance = self.model.create() 
    552         self.failUnlessEqual(len(self.instance.obj),1) 
    553         """Test rule option""" 
    554         def f(model): 
    555           ans=0 
    556           for i in model.x.keys(): 
    557             ans = ans + model.x[i] 
    558           return ans 
    559         self.model.x = Var(RangeSet(1,4),initialize=2) 
    560         self.model.obj = Objective(rule=f) 
    561         self.instance = self.model.create() 
    562         self.failUnlessEqual(len(self.instance.obj),1) 
    563  
    564  
    565 class TestArrayObj(PyomoModel): 
    566  
    567     def setUp(self): 
    568         # 
    569         # Create Model 
    570         # 
    571         PyomoModel.setUp(self) 
    572         self.model.A = Set(initialize=[1,2]) 
    573  
    574     def tearDown(self): 
    575         pass 
    576  
    577     def test_rule_option(self): 
    578         """Test rule option""" 
    579         def f(i,model): 
    580           ans=0 
    581           for j in model.x.keys(): 
    582             ans = ans + model.x[j] 
    583           ans *= i 
    584           return ans 
    585         self.model.x = Var(RangeSet(1,4),initialize=2) 
    586         self.model.obj = Objective(self.model.A,rule=f) 
    587         self.instance = self.model.create() 
    588         try: 
    589             self.instance.obj[1]() 
    590             self.fail("Excepted ValueError due to uninitialized variables") 
    591         except ValueError: 
    592             pass 
    593         self.instance.x.reset() 
    594         self.failUnlessEqual(self.instance.obj[1](), 8) 
    595         self.failUnlessEqual(self.instance.obj[2](), 16) 
    596         self.failUnlessEqual(value(self.instance.obj[1]), 8) 
    597         self.failUnlessEqual(value(self.instance.obj[2]), 16) 
    598  
    599     def test_sense_option(self): 
    600         """Test sense option""" 
    601         self.model.obj = Objective(self.model.A,sense=maximize) 
    602         self.instance = self.model.create() 
    603         self.failUnlessEqual(self.instance.obj.sense, maximize) 
    604  
    605     def test_dim(self): 
    606         """Test dim method""" 
    607         self.model.obj = Objective(self.model.A) 
    608         self.instance = self.model.create() 
    609         self.failUnlessEqual(self.instance.obj.dim(),1) 
    610  
    611     def test_keys(self): 
    612         """Test keys method""" 
    613         def A_rule(i, model): 
    614             return model.x 
    615         self.model.x = Var() 
    616         self.model.obj = Objective(self.model.A, rule=A_rule) 
    617         self.instance = self.model.create() 
    618         self.failUnlessEqual(len(self.instance.obj.keys()),2) 
    619  
    620     def test_len(self): 
    621         """Test len method""" 
    622         self.model.obj = Objective(self.model.A) 
    623         self.instance = self.model.create() 
    624         self.failUnlessEqual(len(self.instance.obj),0) 
    625         """Test rule option""" 
    626         def f(model): 
    627           ans=0 
    628           for i in model.x.keys(): 
    629             ans = ans + model.x[i] 
    630           return ans 
    631         self.model.x = Var(RangeSet(1,4),initialize=2) 
    632         self.model.obj = Objective(rule=f) 
    633         self.instance = self.model.create() 
    634         self.failUnlessEqual(len(self.instance.obj),1) 
    635  
    636  
    637 class Test2DArrayObj(PyomoModel): 
    638  
    639     def setUp(self): 
    640         # 
    641         # Create Model 
    642         # 
    643         PyomoModel.setUp(self) 
    644         self.model.A = Set(initialize=[1,2]) 
    645  
    646     def tearDown(self): 
    647         pass 
    648  
    649     def test_rule_option(self): 
    650         """Test rule option""" 
    651         def f(i,k,model): 
    652           ans=0 
    653           for j in model.x.keys(): 
    654             ans = ans + model.x[j] 
    655           ans *= i 
    656           return ans 
    657         self.model.x = Var(RangeSet(1,4),initialize=2) 
    658         self.model.obj = Objective(self.model.A,self.model.A, rule=f) 
    659         self.instance = self.model.create() 
    660         try: 
    661             self.failUnlessEqual(self.instance.obj(),None) 
    662             self.fail("Expected ValueError") 
    663         except ValueError: 
    664             pass 
    665         self.instance.x.reset() 
    666         self.failUnlessEqual(self.instance.obj[1,1](), 8) 
    667         self.failUnlessEqual(self.instance.obj[2,1](), 16) 
    668         self.failUnlessEqual(value(self.instance.obj[1,1]), 8) 
    669         self.failUnlessEqual(value(self.instance.obj[2,1]), 16) 
    670  
    671     def test_sense_option(self): 
    672         """Test sense option""" 
    673         self.model.obj = Objective(self.model.A,self.model.A,sense=maximize) 
    674         self.instance = self.model.create() 
    675         self.failUnlessEqual(self.instance.obj.sense, maximize) 
    676  
    677     def test_dim(self): 
    678         """Test dim method""" 
    679         self.model.obj = Objective(self.model.A,self.model.A) 
    680         self.instance = self.model.create() 
    681         self.failUnlessEqual(self.instance.obj.dim(),2) 
    682  
    683     def test_keys(self): 
    684         """Test keys method""" 
    685         def A_rule(i,j,model): 
    686             return model.x 
    687         self.model.x = Var() 
    688         self.model.obj = Objective(self.model.A,self.model.A, rule=A_rule) 
    689         self.instance = self.model.create() 
    690         self.failUnlessEqual(len(self.instance.obj.keys()),4) 
    691  
    692     def test_len(self): 
    693         """Test len method""" 
    694         self.model.obj = Objective(self.model.A,self.model.A) 
    695         self.instance = self.model.create() 
    696         self.failUnlessEqual(len(self.instance.obj),0) 
    697         """Test rule option""" 
    698         def f(model): 
    699           ans=0 
    700           for i in model.x.keys(): 
    701             ans = ans + model.x[i] 
    702           return ans 
    703         self.model.x = Var(RangeSet(1,4),initialize=2) 
    704         self.model.obj = Objective(rule=f) 
    705         self.instance = self.model.create() 
    706         self.failUnlessEqual(len(self.instance.obj),1) 
    707  
    708  
    709 class TestSimpleCon(PyomoModel): 
    710  
    711     def setUp(self): 
    712         # 
    713         # Create Model 
    714         # 
    715         PyomoModel.setUp(self) 
    716  
    717     def tearDown(self): 
    718         pass 
    719  
    720     def test_rule1(self): 
    721         """Test rule option""" 
    722         def f(model): 
    723           ans=0 
    724           for i in model.x.keys(): 
    725             ans = ans + model.x[i] 
    726           ans = ans >= 0 
    727           ans = ans <= 1 
    728           return ans 
    729         self.model.x = Var(RangeSet(1,4),initialize=2) 
    730         self.model.c = Constraint(rule=f) 
    731         self.instance = self.model.create() 
    732         try: 
    733           self.failUnlessEqual(self.instance.c(), 8) 
    734         except ValueError: 
    735           pass 
    736         else: 
    737           self.fail("test_rule_option") 
    738         self.instance.x.reset() 
    739         self.failUnlessEqual(self.instance.c(), 8) 
    740         self.failUnlessEqual(value(self.instance.c), 8) 
    741  
    742     def test_rule2(self): 
    743         """Test rule option""" 
    744         def f(model): 
    745           ans=0 
    746           for i in model.x.keys(): 
    747             ans = ans + model.x[i] 
    748           return (0,ans,1) 
    749         self.model.x = Var(RangeSet(1,4),initialize=2) 
    750         self.model.c = Constraint(rule=f) 
    751         self.instance = self.model.create() 
    752         try: 
    753           self.failUnlessEqual(self.instance.c(), 8) 
    754         except ValueError: 
    755           pass 
    756         else: 
    757           self.fail("test_rule_option") 
    758         self.instance.x.reset() 
    759         self.failUnlessEqual(self.instance.c(), 8) 
    760         self.failUnlessEqual(value(self.instance.c), 8) 
    761  
    762     def test_rule3(self): 
    763         """Test rule option""" 
    764         def f(model): 
    765           ans=0 
    766           for i in model.x.keys(): 
    767             ans = ans + model.x[i] 
    768           return (0,ans,None) 
    769         self.model.x = Var(RangeSet(1,4),initialize=2) 
    770         self.model.c = Constraint(rule=f) 
    771         self.instance = self.model.create() 
    772         try: 
    773           self.failUnlessEqual(self.instance.c(), 8) 
    774         except ValueError: 
    775           pass 
    776         else: 
    777           self.fail("test_rule_option") 
    778         self.instance.x.reset() 
    779         self.failUnlessEqual(self.instance.c(), 8) 
    780         self.failUnlessEqual(value(self.instance.c), 8) 
    781  
    782     def test_rule4(self): 
    783         """Test rule option""" 
    784         def f(model): 
    785           ans=0 
    786           for i in model.x.keys(): 
    787             ans = ans + model.x[i] 
    788           return (None,ans,1) 
    789         self.model.x = Var(RangeSet(1,4),initialize=2) 
    790         self.model.c = Constraint(rule=f) 
    791         self.instance = self.model.create() 
    792         try: 
    793           self.failUnlessEqual(self.instance.c(), 8) 
    794         except ValueError: 
    795           pass 
    796         else: 
    797           self.fail("test_rule_option") 
    798         self.instance.x.reset() 
    799         self.failUnlessEqual(self.instance.c(), 8) 
    800         self.failUnlessEqual(value(self.instance.c), 8) 
    801  
    802     def test_rule5(self): 
    803         """Test rule option""" 
    804         def f(model): 
    805           ans=0 
    806           for i in model.x.keys(): 
    807             ans = ans + model.x[i] 
    808           return (ans,1) 
    809         self.model.x = Var(RangeSet(1,4),initialize=2) 
    810         self.model.c = Constraint(rule=f) 
    811         self.instance = self.model.create() 
    812         try: 
    813           self.failUnlessEqual(self.instance.c(), 8) 
    814         except ValueError: 
    815           pass 
    816         else: 
    817           self.fail("test_rule_option") 
    818         self.instance.x.reset() 
    819         self.failUnlessEqual(self.instance.c(), 8) 
    820         self.failUnlessEqual(value(self.instance.c), 8) 
    821  
    822     def test_dim(self): 
    823         """Test dim method""" 
    824         self.model.c = Constraint() 
    825         self.instance = self.model.create() 
    826         self.failUnlessEqual(self.instance.c.dim(),0) 
    827  
    828     def test_keys(self): 
    829         """Test keys method""" 
    830         self.model.c = Constraint() 
    831         self.instance = self.model.create() 
    832         self.failUnlessEqual(self.instance.c.keys(),[]) 
    833  
    834     def test_len(self): 
    835         """Test len method""" 
    836         self.model.c = Constraint() 
    837         self.instance = self.model.create() 
    838         self.failUnlessEqual(len(self.instance.c),0) 
    839         """Test rule option""" 
    840         def f(model): 
    841           ans=0 
    842           for i in model.x.keys(): 
    843             ans = ans + model.x[i] 
    844           ans = ans == 0 
    845           return ans 
    846         self.model.x = Var(RangeSet(1,4),initialize=2) 
    847         self.model.c = Constraint(rule=f) 
    848         self.instance = self.model.create() 
    849         self.failUnlessEqual(len(self.instance.c),1) 
    850  
    851  
    852 class TestArrayCon(PyomoModel): 
    853  
    854     def setUp(self): 
    855         # 
    856         # Create Model 
    857         # 
    858         PyomoModel.setUp(self) 
    859         self.model.A = Set(initialize=[1,2,3,4]) 
    860  
    861     def tearDown(self): 
    862         pass 
    863  
    864     def test_rule_option1(self): 
    865         """Test rule option""" 
    866         def f(i,model): 
    867           ans=0 
    868           for j in model.x.keys(): 
    869             ans = ans + model.x[j] 
    870           ans *= i 
    871           ans = ans < 0 
    872           ans = ans > 0 
    873           return ans 
    874         self.model.x = Var(RangeSet(1,4),initialize=2) 
    875         self.model.c = Constraint(self.model.A,rule=f) 
    876         self.instance = self.model.create() 
    877         try: 
    878             self.instance.c[1]() 
    879             self.fail("Expected ValueError") 
    880         except ValueError: 
    881             pass 
    882         self.instance.x.reset() 
    883         self.failUnlessEqual(self.instance.c[1](), 8) 
    884         self.failUnlessEqual(self.instance.c[2](), 16) 
    885         self.failUnlessEqual(value(self.instance.c[1]), 8) 
    886         self.failUnlessEqual(value(self.instance.c[2]), 16) 
    887         self.failUnlessEqual(len(self.instance.c), 4) 
    888  
    889     def test_rule_option2(self): 
    890         """Test rule option""" 
    891         def f(i,model): 
    892           if i%2 == 0: 
    893                 return 0 
    894           ans=0 
    895           for j in model.x.keys(): 
    896             ans = ans + model.x[j] 
    897           ans *= i 
    898           ans = ans < 0 
    899           ans = ans > 0 
    900           return ans 
    901         self.model.x = Var(RangeSet(1,4),initialize=2) 
    902         self.model.c = Constraint(self.model.A,rule=f) 
    903         self.instance = self.model.create() 
    904         try: 
    905             self.instance.c[1]() 
    906             self.fail("Expected ValueError") 
    907         except ValueError: 
    908             pass 
    909         self.instance.x.reset() 
    910         self.failUnlessEqual(self.instance.c[1](), 8) 
    911         self.failUnlessEqual(value(self.instance.c[1]), 8) 
    912         self.failUnlessEqual(len(self.instance.c), 2) 
    913  
    914     def test_rule_option3(self): 
    915         """Test rule option""" 
    916         def f(i,model): 
    917           if i%2 == 0: 
    918                 return None 
    919           ans=0 
    920           for j in model.x.keys(): 
    921             ans = ans + model.x[j] 
    922           ans *= i 
    923           ans = ans < 0 
    924           ans = ans > 0 
    925           return ans 
    926         self.model.x = Var(RangeSet(1,4),initialize=2) 
    927         self.model.c = Constraint(self.model.A,rule=f) 
    928         self.instance = self.model.create() 
    929         try: 
    930             self.instance.c[1]() 
    931             self.fail("Expected ValueError") 
    932         except ValueError: 
    933             pass 
    934         self.instance.x.reset() 
    935         self.failUnlessEqual(self.instance.c[1](), 8) 
    936         self.failUnlessEqual(value(self.instance.c[1]), 8) 
    937         self.failUnlessEqual(len(self.instance.c), 2) 
    938  
    939     def test_rule_option4(self): 
    940         """Test rule option""" 
    941         def f(model): 
    942           res={} 
    943           for i in [0,1,2]: 
    944                 ans=0 
    945                 for j in model.x.keys(): 
    946                     ans = ans + model.x[j] 
    947                 ans *= i 
    948                 ans = ans < 0 
    949                 ans = ans > 0 
    950                 res[i]=ans 
    951           return res 
    952         self.model.x = Var(RangeSet(1,4),initialize=2) 
    953         self.model.c = Constraint(self.model.A,rule=f) 
    954         try: 
    955             self.instance = self.model.create() 
    956             self.fail("Expected IndexError") 
    957         except IndexError: 
    958             pass 
    959  
    960     def test_dim(self): 
    961         """Test dim method""" 
    962         self.model.c = Constraint(self.model.A) 
    963         self.instance = self.model.create() 
    964         self.failUnlessEqual(self.instance.c.dim(),1) 
    965  
    966     def test_keys(self): 
    967         """Test keys method""" 
    968         self.model.c = Constraint(self.model.A) 
    969         self.instance = self.model.create() 
    970         self.failUnlessEqual(len(self.instance.c.keys()),0) 
    971  
    972     def test_len(self): 
    973         """Test len method""" 
    974         self.model.c = Constraint(self.model.A) 
    975         self.instance = self.model.create() 
    976         self.failUnlessEqual(len(self.instance.c),0) 
    977         """Test rule option""" 
    978         def f(model): 
    979           ans=0 
    980           for i in model.x.keys(): 
    981             ans = ans + model.x[i] 
    982           ans = ans==2 
    983           return ans 
    984         self.model.x = Var(RangeSet(1,4),initialize=2) 
    985         self.model.c = Constraint(rule=f) 
    986         self.instance = self.model.create() 
    987         self.failUnlessEqual(len(self.instance.c),1) 
    988  
    989     def test_rule_error1(self): 
    990         """Verify that errors in the rule dictionary are identified""" 
    991         def f(model): 
    992           res={} 
    993           for i in model.A: 
    994             if i%2 != 0: 
    995                 ans=0 
    996                 for j in model.x.keys(): 
    997                     ans = ans + model.x[j] 
    998                 ans *= i 
    999                 ans = ans < 0 
    1000                 ans = ans > 0 
    1001                 res[i]=ans 
    1002           return res 
    1003         self.model.x = Var(RangeSet(1,4),initialize=2) 
    1004         self.model.c = Constraint(self.model.A,rule=f) 
    1005         self.instance = self.model.create() 
    1006         try: 
    1007             self.instance.c[1]() 
    1008             self.fail("Expected ValueError") 
    1009         except ValueError: 
    1010             pass 
    1011         self.instance.x.reset() 
    1012         self.failUnlessEqual(self.instance.c[1](), 8) 
    1013         self.failUnlessEqual(value(self.instance.c[1]), 8) 
    1014         self.failUnlessEqual(len(self.instance.c), 2) 
    1015  
    1016  
    1017  
    1018 class Test2DArrayCon(PyomoModel): 
    1019  
    1020     def setUp(self): 
    1021         # 
    1022         # Create Model 
    1023         # 
    1024         PyomoModel.setUp(self) 
    1025         self.model.A = Set(initialize=[1,2]) 
    1026  
    1027     def tearDown(self): 
    1028         pass 
    1029  
    1030     def test_rule_option(self): 
    1031         """Test rule option""" 
    1032         def f(i,j,model): 
    1033           ans=0 
    1034           for j in model.x.keys(): 
    1035             ans = ans + model.x[j] 
    1036           ans *= i 
    1037           ans = ans < 0 
    1038           ans = ans > 0 
    1039           return ans 
    1040         self.model.x = Var(RangeSet(1,4),initialize=2) 
    1041         self.model.c = Constraint(self.model.A,self.model.A,rule=f) 
    1042         self.instance = self.model.create() 
    1043         try: 
    1044             self.instance.c[1,1]() 
    1045             self.fail("Expected ValueError") 
    1046         except ValueError: 
    1047             pass 
    1048         self.instance.x.reset() 
    1049         self.failUnlessEqual(self.instance.c[1,1](), 8) 
    1050         self.failUnlessEqual(self.instance.c[2,1](), 16) 
    1051         self.failUnlessEqual(value(self.instance.c[1,1]), 8) 
    1052         self.failUnlessEqual(value(self.instance.c[2,1]), 16) 
    1053  
    1054     def test_dim(self): 
    1055         """Test dim method""" 
    1056         self.model.c = Constraint(self.model.A,self.model.A) 
    1057         self.instance = self.model.create() 
    1058         self.failUnlessEqual(self.instance.c.dim(),2) 
    1059  
    1060     def test_keys(self): 
    1061         """Test keys method""" 
    1062         self.model.c = Constraint(self.model.A,self.model.A) 
    1063         self.instance = self.model.create() 
    1064         self.failUnlessEqual(len(self.instance.c.keys()),0) 
    1065  
    1066     def test_len(self): 
    1067         """Test len method""" 
    1068         self.model.c = Constraint(self.model.A,self.model.A) 
    1069         self.instance = self.model.create() 
    1070         self.failUnlessEqual(len(self.instance.c),0) 
    1071         """Test rule option""" 
    1072         def f(model): 
    1073           ans=0 
    1074           for i in model.x.keys(): 
    1075             ans = ans + model.x[i] 
    1076           ans = ans==2 
    1077           return ans 
    1078         self.model.x = Var(RangeSet(1,4),initialize=2) 
    1079         self.model.c = Constraint(rule=f) 
    1080         self.instance = self.model.create() 
    1081         self.failUnlessEqual(len(self.instance.c),1) 
    1082  
    1083  
    1084 class TestModel(PyomoModel): 
    1085  
    1086     def setUp(self): 
    1087         # 
    1088         # Create Model 
    1089         # 
    1090         PyomoModel.setUp(self) 
    1091  
    1092     def tearDown(self): 
    1093         #pass 
    109439        if os.path.exists("unknown.lp"): 
    109540           os.unlink("unknown.lp") 
     41        pyutilib.services.TempfileManager.clear_tempfiles() 
    109642 
    109743    def test_clear_attribute(self): 
     
    111864        self.model.x = Var(self.model.A, bounds=(-1,1)) 
    111965        def obj_rule(model): 
    1120           expr = 0 
    1121           for i in model.A: 
    1122             expr += model.x[i] 
    1123           return expr 
     66            return summation(model.x) 
    112467        self.model.obj = Objective(rule=obj_rule) 
    112568        self.instance = self.model.create() 
     
    113073        self.model.x = Var(self.model.A, bounds=(-1,1)) 
    113174        def obj_rule(model): 
    1132           expr = 0 
    1133           for i in model.A: 
    1134             expr += model.x[i] 
    1135           return expr 
     75            return summation(model.x) 
    113676        self.model.obj = Objective(rule=obj_rule) 
    113777        def c_rule(model): 
    1138           return (1, model.x[1]+model.x[2], 2) 
     78            return (1, model.x[1]+model.x[2], 2) 
    113979        self.model.c = Constraint(rule=c_rule) 
    114080        self.instance = self.model.create() 
     
    115090 
    115191    def test_solve1(self): 
    1152         self.model.A = RangeSet(1,4) 
    1153         self.model.x = Var(self.model.A, bounds=(-1,1)) 
    1154         def obj_rule(model): 
    1155           expr = 0 
    1156           for i in model.A: 
    1157             expr += model.x[i] 
    1158           return expr 
    1159         self.model.obj = Objective(rule=obj_rule) 
    1160         def c_rule(model): 
    1161           expr = 0 
    1162           for i in model.A: 
    1163             expr += i*model.x[i] 
    1164           return (expr,0) 
    1165         self.model.c = Constraint(rule=c_rule) 
    1166         self.instance = self.model.create() 
    1167         #self.instance.pprint() 
    116892        if not pyutilib.services.registered_executable("glpsol"): 
    116993            return 
    1170         else:    
    1171            opt = SolverFactory('glpk') 
     94        self.model.A = RangeSet(1,4) 
     95        self.model.x = Var(self.model.A, bounds=(-1,1)) 
     96        def obj_rule(model): 
     97            return summation(model.x) 
     98        self.model.obj = Objective(rule=obj_rule) 
     99        def c_rule(model): 
     100            expr = 0 
     101            for i in model.A: 
     102                expr += i*model.x[i] 
     103            return expr == 0 
     104        self.model.c = Constraint(rule=c_rule) 
     105        self.instance = self.model.create() 
     106        #self.instance.pprint() 
     107        opt = SolverFactory('glpk') 
    1172108        solutions = opt.solve(self.instance, keepFiles=True) 
    1173109        self.instance.load(solutions) 
    1174110        self.instance.display(currdir+"solve1.out") 
    1175111        self.failUnlessFileEqualsBaseline(currdir+"solve1.out",currdir+"solve1.txt") 
     112        # 
     113        def d_rule(model): 
     114            return model.x[1] > 0 
     115        self.model.d = Constraint(rule=d_rule) 
     116        self.model.d.deactivate() 
     117        self.instance = self.model.create() 
     118        solutions = opt.solve(self.instance, keepFiles=True) 
     119        self.instance.load(solutions) 
     120        self.instance.display(currdir+"solve1.out") 
     121        self.failUnlessFileEqualsBaseline(currdir+"solve1.out",currdir+"solve1.txt") 
     122        # 
     123        self.model.d.activate() 
     124        self.instance = self.model.create() 
     125        solutions = opt.solve(self.instance, keepFiles=True) 
     126        self.instance.load(solutions) 
     127        self.instance.display(currdir+"solve1.out") 
     128        self.failUnlessFileEqualsBaseline(currdir+"solve1.out",currdir+"solve1a.txt") 
     129        # 
     130        self.model.d.deactivate() 
     131        def e_rule(i, model): 
     132            return model.x[i] > 0 
     133        self.model.e = Constraint(self.model.A, rule=e_rule) 
     134        self.instance = self.model.create() 
     135        for i in self.instance.A: 
     136            self.instance.e[i].deactivate() 
     137        solutions = opt.solve(self.instance, keepFiles=True) 
     138        self.instance.load(solutions) 
     139        self.instance.display(currdir+"solve1.out") 
     140        self.failUnlessFileEqualsBaseline(currdir+"solve1.out",currdir+"solve1b.txt") 
    1176141 
    1177142    def Xtest_solve2(self): 
     
    1181146        impacted this test... 
    1182147        """ 
     148        if not pyutilib.services.registered_executable("glpsol"): 
     149            return 
    1183150        self.model.A = RangeSet(1,4) 
    1184151        self.model.x = Var(self.model.A, bounds=(-1,1)) 
     
    1191158        self.instance = self.model.create() 
    1192159        #self.instance.pprint() 
    1193         if not pyutilib.services.registered_executable("glpsol"): 
    1194             return 
    1195         else:    
    1196            opt = solvers.GLPK(keepFiles=True) 
     160        opt = solvers.GLPK(keepFiles=True) 
    1197161        solutions = opt.solve(self.instance) 
    1198162        solutions.write() 
     
    1218182 
    1219183    def test_solve4(self): 
    1220         self.model.A = RangeSet(1,4) 
    1221         self.model.x = Var(self.model.A, bounds=(-1,1)) 
    1222         def obj_rule(model): 
    1223           expr = 0 
    1224           for i in model.A: 
    1225             expr += model.x[i] 
    1226           return expr 
     184        if not pyutilib.services.registered_executable("glpsol"): 
     185            return 
     186        self.model.A = RangeSet(1,4) 
     187        self.model.x = Var(self.model.A, bounds=(-1,1)) 
     188        def obj_rule(model): 
     189            return summation(model.x) 
    1227190        self.model.obj = Objective(rule=obj_rule) 
    1228191        def c_rule(model): 
     
    1230193          for i in model.A: 
    1231194            expr += i*model.x[i] 
    1232           return (expr,0) 
     195          return expr == 0 
    1233196        self.model.c = Constraint(rule=c_rule) 
    1234197        self.instance = self.model.create() 
    1235198        #self.instance.pprint() 
    1236         if not pyutilib.services.registered_executable("glpsol"): 
    1237             return 
    1238         else:    
    1239            opt = SolverFactory('glpk', keepFiles=True) 
     199        opt = SolverFactory('glpk', keepFiles=True) 
    1240200        solutions = opt.solve(self.instance) 
    1241201        self.instance.load(solutions.solution(0)) 
Note: See TracChangeset for help on using the changeset viewer.