Changeset 3646


Ignore:
Timestamp:
Feb 17, 2011 1:51:32 PM (9 years ago)
Author:
jdsiiro
Message:

Changing the semantics for Var.initial so that upon construction (or
after reset) var.initial == var.value.

  • Calling reset() directly after model.create() should no longer be necessary.
  • After reset(), any variables that do not have an initialization source (rule, dict, or constant) will be reset back to var.value == None.
Location:
coopr.pyomo/trunk/coopr/pyomo
Files:
5 edited

Legend:

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

    r3617 r3646  
    316316
    317317    def reset(self):
    318         for key in self._varval:
    319             if not self._varval[key].initial is None:
    320                 self._varval[key].set_value( self._varval[key].initial )
     318        for value in self._varval.itervalues():
     319            value.set_value(value.initial)
    321320
    322321    def __len__(self):
     
    429428        # Initialize values with a dictionary if provided
    430429        #
    431         if self._initialize is not None and \
    432            type(self._initialize) is not types.FunctionType:
    433 
    434            if type(self._initialize) is dict:
    435               for key in self._initialize:
    436                 self._varval[key].value = None
    437                 self._varval[key].initial = self._initialize[key]
    438                 self._valid_value(self._initialize[key],True)
    439            else:
    440               for key in self._index:
    441                 self._varval[key].value = None
    442                 self._varval[key].initial = self._initialize
    443               self._valid_value(self._initialize,True)
    444         #
    445         # Initialize values with the _rule function if provided
    446         #
    447         elif type(self._initialize) is types.FunctionType:
    448            for key in self._varval:
    449              if isinstance(key,tuple):
    450                 tmp = list(key)
    451              elif key is None:
    452                 tmp = []
    453              else:
    454                 tmp = [key]
    455              tmp.append(self.model)
    456              tmp = tuple(tmp)
    457              self._varval[key].value = None
    458              self._varval[key].initial = self._initialize(*tmp)
    459              self._valid_value(self._varval[key].initial,True)
     430        if self._initialize is not None:
     431            #
     432            # Initialize values with the _rule function if provided
     433            #
     434            if self._initialize.__class__ is types.FunctionType:
     435                for key in self._varval:
     436                    if key is None:
     437                        tmp = []
     438                    elif key.__class__ is tuple:
     439                        tmp = list(key)
     440                    else:
     441                        tmp = [key]
     442                    tmp.append(self.model)
     443                    val = self._initialize(*tuple(tmp))
     444                    self._valid_value(val, True)
     445                    self._varval[key].value = self._varval[key].initial = val
     446            elif self._initialize.__class__ is dict:
     447                for key in self._initialize:
     448                    val = self._initialize[key]
     449                    self._valid_value(val, True)
     450                    self._varval[key].value = self._varval[key].initial = val
     451            else:
     452                for key in self._index:
     453                    val = self._initialize
     454                    self._valid_value(val, True)
     455                    self._varval[key].value = self._varval[key].initial = val
    460456        #
    461457        # Initialize bounds with the bounds function if provided
  • coopr.pyomo/trunk/coopr/pyomo/tests/unit/test_con.py

    r3446 r3646  
    3939        pass
    4040
    41     def test_expr1(self):
    42         """Test expr option"""
    43         self.model = ConcreteModel()
    44         self.model.x = Var(RangeSet(1,4),initialize=2)
     41    def test_set_expr_explicit_multivariate(self):
     42        """Test expr= option (multivariate expression)"""
     43        model = ConcreteModel()
     44        model.x = Var(RangeSet(1,4),initialize=2)
    4545        ans=0
    46         for i in self.model.x.keys():
    47             ans = ans + self.model.x[i]
     46        for i in model.x.keys():
     47            ans = ans + model.x[i]
    4848        ans = ans >= 0
    4949        ans = ans <= 1
    50         self.model.c = Constraint(expr=ans)
    51         self.instance = self.model.create()
     50        model.c = Constraint(expr=ans)
     51        instance = model.create()
     52        self.failUnlessEqual(instance.c(), 8)
     53        self.failUnlessEqual(value(instance.c), 8)
     54
     55    def test_set_expr_explicit_univariate(self):
     56        """Test expr= option (univariate expression)"""
     57        model = ConcreteModel()
     58        model.x = Var(initialize=2)
     59        ans = model.x >= 0
     60        ans = ans <= 1
     61        model.c = Constraint(expr=ans)
     62        instance = model.create()
     63        self.failUnlessEqual(instance.c(), 2)
     64        self.failUnlessEqual(value(instance.c), 2)
     65
     66    def test_set_expr_undefined_univariate(self):
     67        """Test expr= option (univariate expression)"""
     68        model = ConcreteModel()
     69        model.x = Var()
     70        ans = model.x >= 0
     71        ans = ans <= 1
     72        model.c = Constraint(expr=ans)
     73        instance = model.create()
    5274        try:
    53             self.failUnlessEqual(self.instance.c(), 8)
    54         except ValueError:
    55             pass
    56         else:
    57             self.fail("test_expr_option")
    58         self.instance.x.reset()
    59         self.failUnlessEqual(self.instance.c(), 8)
    60         self.failUnlessEqual(value(self.instance.c), 8)
    61 
    62     def test_expr2(self):
    63         """Test expr option"""
    64         self.model = ConcreteModel()
    65         self.model.x = Var(initialize=2)
    66         ans = self.model.x >= 0
    67         ans = ans <= 1
    68         self.model.c = Constraint(expr=ans)
    69         self.instance = self.model.create()
    70         self.instance.x.reset()
    71         self.failUnlessEqual(self.instance.c(), 2)
    72         self.failUnlessEqual(value(self.instance.c), 2)
    73 
    74     def test_rule1(self):
    75         """Test rule option"""
    76         def f(model):
    77           ans=0
    78           for i in model.x.keys():
    79             ans = ans + model.x[i]
    80           ans = ans >= 0
    81           ans = ans <= 1
    82           return ans
    83         self.model.x = Var(RangeSet(1,4),initialize=2)
    84         self.model.c = Constraint(rule=f)
    85         self.instance = self.model.create()
    86         try:
    87           self.failUnlessEqual(self.instance.c(), 8)
     75          self.failUnlessEqual(instance.c(), 8)
    8876        except ValueError:
    8977          pass
    9078        else:
    91           self.fail("test_rule_option")
    92         self.instance.x.reset()
     79          self.fail("Expected ValueError evaluating expression with x==None")
     80        instance.x = 2
     81        self.failUnlessEqual(instance.c(), 2)
     82        self.failUnlessEqual(value(instance.c), 2)
     83       
     84    def test_set_expr_inline(self):
     85        """Test expr= option (inline expression)"""
     86        model = ConcreteModel()
     87        model.A = RangeSet(1,4)
     88        model.x = Var(model.A,initialize=2)
     89        model.c = Constraint(expr=0 <= sum(model.x[i] for i in model.A) <= 1)
     90        instance = model.create()
     91        self.failUnlessEqual(instance.c(), 8)
     92        self.failUnlessEqual(value(instance.c), 8)
     93       
     94
     95    def test_rule1(self):
     96        """Test rule option"""
     97        def f(model):
     98          ans=0
     99          for i in model.x.keys():
     100            ans = ans + model.x[i]
     101          ans = ans >= 0
     102          ans = ans <= 1
     103          return ans
     104        self.model.x = Var(RangeSet(1,4),initialize=2)
     105        self.model.c = Constraint(rule=f)
     106        self.instance = self.model.create()
    93107        self.failUnlessEqual(self.instance.c(), 8)
    94108        self.failUnlessEqual(value(self.instance.c), 8)
     
    104118        self.model.c = Constraint(rule=f)
    105119        self.instance = self.model.create()
    106         try:
    107           self.failUnlessEqual(self.instance.c(), 8)
    108         except ValueError:
    109           pass
    110         else:
    111           self.fail("test_rule_option")
    112         self.instance.x.reset()
    113120        self.failUnlessEqual(self.instance.c(), 8)
    114121        self.failUnlessEqual(value(self.instance.c), 8)
     
    124131        self.model.c = Constraint(rule=f)
    125132        self.instance = self.model.create()
    126         try:
    127           self.failUnlessEqual(self.instance.c(), 8)
    128         except ValueError:
    129           pass
    130         else:
    131           self.fail("test_rule_option")
    132         self.instance.x.reset()
    133133        self.failUnlessEqual(self.instance.c(), 8)
    134134        self.failUnlessEqual(value(self.instance.c), 8)
     
    144144        self.model.c = Constraint(rule=f)
    145145        self.instance = self.model.create()
    146         try:
    147           self.failUnlessEqual(self.instance.c(), 8)
    148         except ValueError:
    149           pass
    150         else:
    151           self.fail("test_rule_option")
    152         self.instance.x.reset()
    153146        self.failUnlessEqual(self.instance.c(), 8)
    154147        self.failUnlessEqual(value(self.instance.c), 8)
     
    164157        self.model.c = Constraint(rule=f)
    165158        self.instance = self.model.create()
    166         try:
    167           self.failUnlessEqual(self.instance.c(), 8)
    168         except ValueError:
    169           pass
    170         else:
    171           self.fail("test_rule_option")
    172         self.instance.x.reset()
    173159        self.failUnlessEqual(self.instance.c(), 8)
    174160        self.failUnlessEqual(value(self.instance.c), 8)
     
    218204        self.model.c = Constraint(self.model.A,rule=f)
    219205        self.instance = self.model.create()
    220         try:
    221             self.instance.c[1]()
    222             self.fail("Expected ValueError")
    223         except ValueError:
    224             pass
    225         self.instance.x.reset()
    226206        self.failUnlessEqual(self.instance.c[1](), 8)
    227207        self.failUnlessEqual(self.instance.c[2](), 16)
     
    245225        self.model.c = Constraint(self.model.A,rule=f)
    246226        self.instance = self.model.create()
    247         try:
    248             self.instance.c[1]()
    249             self.fail("Expected ValueError")
    250         except ValueError:
    251             pass
    252         self.instance.x.reset()
    253227        self.failUnlessEqual(self.instance.c[1](), 8)
    254228        self.failUnlessEqual(value(self.instance.c[1]), 8)
     
    270244        self.model.c = Constraint(self.model.A,rule=f)
    271245        self.instance = self.model.create()
    272         try:
    273             self.instance.c[1]()
    274             self.fail("Expected ValueError")
    275         except ValueError:
    276             pass
    277         self.instance.x.reset()
    278246        self.failUnlessEqual(self.instance.c[1](), 8)
    279247        self.failUnlessEqual(value(self.instance.c[1]), 8)
     
    337305        self.model.c = ConstraintList(rule=f)
    338306        self.instance = self.model.create()
    339         try:
    340             self.instance.c[1]()
    341             self.fail("Expected ValueError")
    342         except ValueError:
    343             pass
    344         self.instance.x.reset()
    345307        self.failUnlessEqual(self.instance.c[1](), 8)
    346308        self.failUnlessEqual(self.instance.c[2](), 16)
     
    365327        self.model.c = ConstraintList(rule=f)
    366328        self.instance = self.model.create()
    367         try:
    368             self.instance.c[1]()
    369             self.fail("Expected ValueError")
    370         except ValueError:
    371             pass
    372         self.instance.x.reset()
    373329        self.failUnlessEqual(self.instance.c[1](), 8)
    374330        self.failUnlessEqual(value(self.instance.c[1]), 8)
     
    419375        self.model.c = Constraint(self.model.A,self.model.A,rule=f)
    420376        self.instance = self.model.create()
    421         try:
    422             self.instance.c[1,1]()
    423             self.fail("Expected ValueError")
    424         except ValueError:
    425             pass
    426         self.instance.x.reset()
    427377        self.failUnlessEqual(self.instance.c[1,1](), 8)
    428378        self.failUnlessEqual(self.instance.c[2,1](), 16)
  • coopr.pyomo/trunk/coopr/pyomo/tests/unit/test_obj.py

    r3548 r3646  
    4141    def test_expr1_option(self):
    4242        """Test expr option"""
    43         self.model = ConcreteModel()
    44         self.model.x = Var(RangeSet(1,4),initialize=2)
     43        model = ConcreteModel()
     44        model.x = Var(RangeSet(1,4),initialize=2)
    4545        ans=0
    46         for i in self.model.x.keys():
    47             ans = ans + self.model.x[i]
    48         self.model.obj = Objective(expr=ans)
    49         self.instance = self.model.create()
    50         try:
    51           self.failUnlessEqual(self.instance.obj(), 8)
    52         except ValueError:
    53           pass
    54         else:
    55           self.fail("test_expr_option")
    56         self.instance.x.reset()
    57         self.failUnlessEqual(self.instance.obj(), 8)
    58         self.failUnlessEqual(value(self.instance.obj), 8)
     46        for i in model.x.keys():
     47            ans = ans + model.x[i]
     48        model.obj = Objective(expr=ans)
     49        instance = model.create()
     50        self.failUnlessEqual(instance.obj(), 8)
     51        self.failUnlessEqual(value(instance.obj), 8)
    5952
    6053    def test_expr2_option(self):
    6154        """Test expr option"""
    62         self.model = ConcreteModel()
    63         self.model.x = Var(initialize=2)
    64         self.model.obj = Objective(expr=self.model.x)
    65         self.instance = self.model.create()
    66         self.instance.x.reset()
    67         #print 'X',type(self.instance.obj.rule)
    68         self.failUnlessEqual(self.instance.obj(), 2)
    69         self.failUnlessEqual(value(self.instance.obj), 2)
     55        model = ConcreteModel()
     56        model.x = Var(initialize=2)
     57        model.obj = Objective(expr=model.x)
     58        instance = model.create()
     59        instance.x.reset()
     60        #print 'X',type(instance.obj.rule)
     61        self.failUnlessEqual(instance.obj(), 2)
     62        self.failUnlessEqual(value(instance.obj), 2)
    7063
    7164    def test_rule_option(self):
     
    7972        self.model.obj = Objective(rule=f)
    8073        self.instance = self.model.create()
    81         try:
    82           self.failUnlessEqual(self.instance.obj(), 8)
    83         except ValueError:
    84           pass
    85         else:
    86           self.fail("test_rule_option")
    87         self.instance.x.reset()
    8874        self.failUnlessEqual(self.instance.obj(), 8)
    8975        self.failUnlessEqual(value(self.instance.obj), 8)
     
    167153        self.model.obj = Objective(self.model.A,rule=f)
    168154        self.instance = self.model.create()
    169         try:
    170             self.instance.obj[1]()
    171             self.fail("Excepted ValueError due to uninitialized variables")
    172         except ValueError:
    173             pass
    174         self.instance.x.reset()
    175155        self.failUnlessEqual(self.instance.obj[1](), 8)
    176156        self.failUnlessEqual(self.instance.obj[2](), 16)
  • coopr.pyomo/trunk/coopr/pyomo/tests/unit/test_var.py

    r3554 r3646  
    110110        self.failUnlessEqual(type(self.model.x.domain), IntegerSet)
    111111
    112     def test_initialize_option(self):
    113         """Test initialize option"""
    114         self.model.x = Var(initialize=1.3)
    115         self.instance = self.model.create()
    116         self.failUnlessEqual(self.instance.x.initial, 1.3)
    117 
    118112    def test_bounds_option1(self):
    119113        """Test bounds option"""
     
    138132        self.model.x = Var(initialize=x_init)
    139133        self.instance = self.model.create()
    140         self.failUnlessEqual(self.instance.x.value, None)
     134        self.failUnlessEqual(self.instance.x.value, 1.3)
    141135        self.failUnlessEqual(self.instance.x.initial, 1.3)
    142136
    143     def test_reset(self):
     137    def test_initialize_reset_with_function(self):
     138        """Test initialize option / reset method with an initialization rule"""
     139        def init_rule(model):
     140            return 1.3
     141        self.model.x = Var(initialize=init_rule)
     142        self.instance = self.model.create()
     143        self.failUnlessEqual(self.instance.x, 1.3)
     144        self.instance.x = 1
     145        self.failUnlessEqual(self.instance.x, 1)
     146        self.instance.reset()
     147        self.failUnlessEqual(self.instance.x, 1.3)
     148
     149    def test_initialize_reset_with_dict(self):
     150        """Test initialize option / reset method with a dictionary"""
     151        self.model.x = Var(initialize={None:1.3})
     152        self.instance = self.model.create()
     153        self.failUnlessEqual(self.instance.x, 1.3)
     154        self.instance.x = 1
     155        self.failUnlessEqual(self.instance.x, 1)
     156        self.instance.reset()
     157        self.failUnlessEqual(self.instance.x, 1.3)
     158
     159    def test_initialize_reset_with_const(self):
     160        """Test initialize option / reset method with a constant"""
     161        self.model.x = Var(initialize=1.3)
     162        self.instance = self.model.create()
     163        self.failUnlessEqual(self.instance.x, 1.3)
     164        self.instance.x = 1
     165        self.failUnlessEqual(self.instance.x, 1)
     166        self.instance.reset()
     167        self.failUnlessEqual(self.instance.x, 1.3)
     168
     169    def test_reset_without_initial_value(self):
    144170        """Test reset method"""
    145         self.model.x = Var(initialize=3)
    146         self.instance = self.model.create()
    147         self.failUnlessEqual(self.instance.x.initial,3)
    148         self.failUnlessEqual(self.instance.x.value,None)
     171        self.model.x = Var()
     172        self.instance = self.model.create()
     173        self.assertEqual(self.instance.x.initial,None)
     174        self.assertEqual(self.instance.x.value,None)
     175        self.instance.x = 5
     176        self.assertEqual(self.instance.x.initial,None)
     177        self.assertEqual(self.instance.x.value,5)
    149178        self.instance.x.reset()
    150         self.failUnlessEqual(self.instance.x.initial,3)
    151         self.failUnlessEqual(self.instance.x.initial,3)
     179        self.assertEqual(self.instance.x.initial,None)
     180        self.assertEqual(self.instance.x.value,None)
    152181
    153182    def test_dim(self):
     
    243272        #self.failUnlessEqual(self.instance.x[1].ub(), 1.0)
    244273
    245     def test_initialize_option(self):
    246         """Test initialize option"""
    247         self.model.x = Var(self.model.A,initialize={1:1.3,2:2.3})
    248         self.instance = self.model.create()
    249         self.instance.reset()
     274    def test_initialize_reset_with_function(self):
     275        """Test initialize option / reset method with an initialization rule"""
     276        def init_rule(key, model):
     277            return key == 1 and 1.3 or 2.3
     278        self.model.x = Var(self.model.A,initialize=init_rule)
     279        self.instance = self.model.create()
    250280        self.failUnlessEqual(self.instance.x[1], 1.3)
    251281        self.failUnlessEqual(self.instance.x[2], 2.3)
     282        self.instance.x[1] = 1
     283        self.instance.x[2] = 2
     284        self.failUnlessEqual(self.instance.x[1], 1)
     285        self.failUnlessEqual(self.instance.x[2], 2)
     286        self.instance.reset()
     287        self.failUnlessEqual(self.instance.x[1], 1.3)
     288        self.failUnlessEqual(self.instance.x[2], 2.3)
     289
     290    def test_initialize_reset_with_dict(self):
     291        """Test initialize option / reset method with a dictionary"""
     292        self.model.x = Var(self.model.A,initialize={1:1.3,2:2.3})
     293        self.instance = self.model.create()
     294        self.failUnlessEqual(self.instance.x[1], 1.3)
     295        self.failUnlessEqual(self.instance.x[2], 2.3)
     296        self.instance.x[1] = 1
     297        self.instance.x[2] = 2
     298        self.failUnlessEqual(self.instance.x[1], 1)
     299        self.failUnlessEqual(self.instance.x[2], 2)
     300        self.instance.reset()
     301        self.failUnlessEqual(self.instance.x[1], 1.3)
     302        self.failUnlessEqual(self.instance.x[2], 2.3)
     303
     304    def test_initialize_reset_with_const(self):
     305        """Test initialize option / reset method with a constant"""
     306        self.model.x = Var(self.model.A,initialize=3)
     307        self.instance = self.model.create()
     308        self.failUnlessEqual(self.instance.x[1], 3)
     309        self.failUnlessEqual(self.instance.x[2], 3)
     310        self.instance.x[1] = 1
     311        self.instance.x[2] = 2
     312        self.failUnlessEqual(self.instance.x[1], 1)
     313        self.failUnlessEqual(self.instance.x[2], 2)
     314        self.instance.reset()
     315        self.failUnlessEqual(self.instance.x[1], 3)
     316        self.failUnlessEqual(self.instance.x[2], 3)
     317
     318    def test_reset_without_initial_value(self):
     319        """Test reset method"""
     320        self.model.x = Var(self.model.A)
     321        self.instance = self.model.create()
     322        self.assertEqual(self.instance.x[1].initial,None)
     323        self.assertEqual(self.instance.x[1].value,None)
     324        self.assertEqual(self.instance.x[2].initial,None)
     325        self.assertEqual(self.instance.x[2].value,None)
     326        self.instance.x[1] = 5
     327        self.instance.x[2] = 6
     328        self.assertEqual(self.instance.x[1].initial,None)
     329        self.assertEqual(self.instance.x[1].value,5)
     330        self.assertEqual(self.instance.x[2].initial,None)
     331        self.assertEqual(self.instance.x[2].value,6)
     332        self.instance.x.reset()
     333        self.assertEqual(self.instance.x[1].initial,None)
     334        self.assertEqual(self.instance.x[1].value,None)
     335        self.assertEqual(self.instance.x[2].initial,None)
     336        self.assertEqual(self.instance.x[2].value,None)
    252337
    253338    def test_bounds_option1(self):
     
    274359        self.instance = self.model.create()
    275360        self.failUnlessEqual(self.instance.x[1].initial, 1.3)
    276 
    277     def test_reset(self):
    278         """Test reset method"""
    279         self.model.x = Var(self.model.A,initialize=3)
    280         self.instance = self.model.create()
    281         self.failUnlessEqual(self.instance.x[1].initial,3)
    282         self.failUnlessEqual(self.instance.x[1].value,None)
    283         self.instance.x.reset()
    284         self.failUnlessEqual(self.instance.x[1].initial,3)
    285         self.failUnlessEqual(self.instance.x[1].initial,3)
    286361
    287362    def test_dim(self):
     
    377452        #self.failUnlessEqual(self.instance.x[2,1].ub(), 1.0)
    378453
     454    def test_initialize_reset_with_function(self):
     455        """Test initialize option / reset method with an initialization rule"""
     456        def init_rule(key1, key2, model):
     457            return key1 == 1 and 1.3 or 2.3
     458        self.model.x = Var(self.model.A,self.model.A,initialize=init_rule)
     459        self.instance = self.model.create()
     460        self.failUnlessEqual(self.instance.x[1,1], 1.3)
     461        self.failUnlessEqual(self.instance.x[2,2], 2.3)
     462        self.instance.x[1,1] = 1
     463        self.instance.x[2,2] = 2
     464        self.failUnlessEqual(self.instance.x[1,1], 1)
     465        self.failUnlessEqual(self.instance.x[2,2], 2)
     466        self.instance.reset()
     467        self.failUnlessEqual(self.instance.x[1,1], 1.3)
     468        self.failUnlessEqual(self.instance.x[2,2], 2.3)
     469
     470    def test_initialize_reset_with_dict(self):
     471        """Test initialize option / reset method with a dictionary"""
     472        self.model.x = Var(self.model.A,self.model.A,
     473                           initialize={(1,1):1.3,(2,2):2.3})
     474        self.instance = self.model.create()
     475        self.failUnlessEqual(self.instance.x[1,1], 1.3)
     476        self.failUnlessEqual(self.instance.x[2,2], 2.3)
     477        self.instance.x[1,1] = 1
     478        self.instance.x[2,2] = 2
     479        self.failUnlessEqual(self.instance.x[1,1], 1)
     480        self.failUnlessEqual(self.instance.x[2,2], 2)
     481        self.instance.reset()
     482        self.failUnlessEqual(self.instance.x[1,1], 1.3)
     483        self.failUnlessEqual(self.instance.x[2,2], 2.3)
     484
     485    def test_initialize_reset_with_const(self):
     486        """Test initialize option / reset method with a constant"""
     487        self.model.x = Var(self.model.A,self.model.A,initialize=3)
     488        self.instance = self.model.create()
     489        self.failUnlessEqual(self.instance.x[1,1], 3)
     490        self.failUnlessEqual(self.instance.x[2,2], 3)
     491        self.instance.x[1,1] = 1
     492        self.instance.x[2,2] = 2
     493        self.failUnlessEqual(self.instance.x[1,1], 1)
     494        self.failUnlessEqual(self.instance.x[2,2], 2)
     495        self.instance.reset()
     496        self.failUnlessEqual(self.instance.x[1,1], 3)
     497        self.failUnlessEqual(self.instance.x[2,2], 3)
     498
     499    def test_reset_without_initial_value(self):
     500        """Test reset method"""
     501        self.model.x = Var(self.model.A,self.model.A)
     502        self.instance = self.model.create()
     503        self.assertEqual(self.instance.x[1,1].initial,None)
     504        self.assertEqual(self.instance.x[1,1].value,None)
     505        self.assertEqual(self.instance.x[2,2].initial,None)
     506        self.assertEqual(self.instance.x[2,2].value,None)
     507        self.instance.x[1,1] = 5
     508        self.instance.x[2,2] = 6
     509        self.assertEqual(self.instance.x[1,1].initial,None)
     510        self.assertEqual(self.instance.x[1,1].value,5)
     511        self.assertEqual(self.instance.x[2,2].initial,None)
     512        self.assertEqual(self.instance.x[2,2].value,6)
     513        self.instance.x.reset()
     514        self.assertEqual(self.instance.x[1,1].initial,None)
     515        self.assertEqual(self.instance.x[1,1].value,None)
     516        self.assertEqual(self.instance.x[2,2].initial,None)
     517        self.assertEqual(self.instance.x[2,2].value,None)
     518
    379519    def test_initialize_option(self):
    380520        """Test initialize option"""
     
    413553        self.instance = self.model.create()
    414554        self.failUnlessEqual(self.instance.x[1,2].initial, 1.3)
    415 
    416     def test_reset(self):
    417         """Test reset method"""
    418         self.model.x = Var(self.model.A,self.model.A, initialize=3)
    419         self.instance = self.model.create()
    420         self.failUnlessEqual(self.instance.x[1,1].initial,3)
    421         self.failUnlessEqual(self.instance.x[1,1].value,None)
    422         self.instance.x.reset()
    423         self.failUnlessEqual(self.instance.x[1,1].initial,3)
    424         self.failUnlessEqual(self.instance.x[1,1].initial,3)
    425555
    426556    def test_dim(self):
  • coopr.pyomo/trunk/coopr/pyomo/tests/unit/varpprint.txt

    r3554 r3646  
    2323   b :  Size=3  Domain=PositiveReals
    2424        Key : Initial Value : Lower Bound : Upper Bound : Current Value: Fixed: Status
    25         1 : 1.1 : 0 : None : None : False : used
    26         2 : 1.1 : 0 : None : None : False : used
    27         3 : 1.1 : 0 : None : None : False : used
     25        1 : 1.1 : 0 : None : 1.1 : False : used
     26        2 : 1.1 : 0 : None : 1.1 : False : used
     27        3 : 1.1 : 0 : None : 1.1 : False : used
    2828   c :  Size=1  Domain=PositiveReals
    2929        Initial Value : Lower Bound : Upper Bound : Current Value: Fixed: Status
    30          2.1 : 0 : None : None : False : used
     30         2.1 : 0 : None : 2.1 : False : used
    3131   d :  Size=1  Domain=PositiveReals
    3232        Initial Value : Lower Bound : Upper Bound : Current Value: Fixed: Status
    33          3.1 : 0 : None : None : False : used
     33         3.1 : 0 : None : 3.1 : False : used
    3434   e :  Size=1  Domain=PositiveReals
    3535        Initial Value : Lower Bound : Upper Bound : Current Value: Fixed: Status
    36          4.1 : 0 : None : None : False : unused
     36         4.1 : 0 : None : 4.1 : False : unused
    3737
    38382 Objective Declarations
Note: See TracChangeset for help on using the changeset viewer.