Changeset 4153


Ignore:
Timestamp:
06/02/11 22:54:35 (3 years ago)
Author:
wehart
Message:

Changing the default semantics for rules used to
generate sets, objectives and variables. The use of None, True and
False is no longer supported, except with decorator functions.

Location:
coopr.pyomo/trunk
Files:
7 edited

Legend:

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

    r4119 r4153  
    99#  _________________________________________________________________________ 
    1010 
    11 __all__ = ['Constraint', 'SOSConstraint', 'ConstraintBase', 'ConstraintList'] 
     11__all__ = ['Constraint', 'SOSConstraint', 'ConstraintBase', 'ConstraintList', 'simple_constraint_rule', 'simple_constraintlist_rule'] 
    1212 
    1313import sys 
     
    3434 
    3535 
     36def simple_constraint_rule( fn ): 
     37    """This is a decorator that translates None/True/False return values 
     38    into Constraint.Skip/Constraint.Feasible/Constraint.Infeasible. 
     39    This supports a simpler syntax in constraint rules, though these can be 
     40    more difficult to debug when errors occur. 
     41 
     42    Example use: 
     43 
     44    @simple_constraint_rule 
     45    def C_rule(model, i, j): 
     46        ... 
     47    """ 
     48 
     49    def wrapper_function ( *args, **kwargs ): 
     50        value = fn( *args, **kwargs ) 
     51        if value is None: 
     52            return Constraint.Skip 
     53        elif value is True: 
     54            return Constraint.Feasible 
     55        elif value is False: 
     56            return Constraint.Infeasible 
     57        return value 
     58    return wrapper_function 
     59 
     60 
     61def simple_constraintlist_rule( fn ): 
     62    """This is a decorator that translates None/True/False return values 
     63    into ConstraintList.End/Constraint.Feasible/Constraint.Infeasible. 
     64    This supports a simpler syntax in constraint rules, though these can be 
     65    more difficult to debug when errors occur. 
     66 
     67    Example use: 
     68 
     69    @simple_constraintlist_rule 
     70    def C_rule(model, i, j): 
     71        ... 
     72    """ 
     73 
     74    def wrapper_function ( *args, **kwargs ): 
     75        value = fn( *args, **kwargs ) 
     76        if value is None: 
     77            return ConstraintList.End 
     78        elif value is True: 
     79            return Constraint.Feasible 
     80        elif value is False: 
     81            return Constraint.Infeasible 
     82        return value 
     83    return wrapper_function 
     84 
     85 
     86 
    3687class ConstraintBase(IndexedComponent): 
    3788    """ 
     
    181232 
    182233    alias("Constraint", "Constraint expressions in a model.") 
     234 
     235    NoConstraint    = (1000,) 
     236    Skip            = (1000,) 
     237    Infeasible      = (1001,) 
     238    Violated        = (1001,) 
     239    Feasible        = (1002,) 
     240    Satisfied       = (1002,) 
    183241 
    184242    def __init__(self, *args, **kwargs): 
     
    296354            else: 
    297355                expr = _self_rule(_self_model) 
    298             if expr is not None: 
    299                 self.add(None, expr) 
     356            self.add(None, expr) 
    300357        else: 
    301358            if isinstance(_self_rule,Expression): 
     
    316373                        expr = _self_rule(index, _self_model) 
    317374                    logger.warning("DEPRECATION WARNING: Using constraint rule with model argument last") 
    318                 if expr is not None: 
    319                     self.add(index, expr) 
     375                self.add(index, expr) 
    320376 
    321377    def add(self, index, expr): 
    322  
    323378        # index: the constraint index (should probably be renamed) 
    324379        # expr: the constraint expression 
    325380 
     381        # Convert deprecated expression values 
     382        if expr is None: 
     383            logger.warning("DEPRECATION WARNING: Constraint rule returned None instead of Constraint.Skip") 
     384            expr = Constraint.Skip 
     385        if expr is True: 
     386            logger.warning("DEPRECATION WARNING: Constraint rule returned True instead of Constraint.Feasible") 
     387            expr = Constraint.Feasible 
     388        if expr is False: 
     389            logger.warning("DEPRECATION WARNING: Constraint rule returned False instead of Constraint.Infeasible") 
     390            expr = Constraint.Infeasible 
     391        # 
     392        expr_type = type(expr) 
    326393        # 
    327394        # Ignore an 'empty' constraint 
    328395        # 
    329         if expr is None: 
    330             return 
    331         expr_type = type(expr) 
    332  
     396        if expr_type is tuple and len(expr) == 1: 
     397            if expr == Constraint.Skip or expr == Constraint.Feasible: 
     398                return 
     399            if expr == Constraint.Infeasible: 
     400                raise ValueError, "Constraint '%s' is always infeasible" % create_name(self.name,index) 
     401        # 
     402        # 
    333403        # Local variables to optimize runtime performance 
    334404        # 
     
    658728    alias("ConstraintList", "A list of constraints in a model.") 
    659729 
     730    End             = (1003,) 
     731 
    660732    def __init__(self, *args, **kwargs): 
    661733        if len(args) > 0: 
     
    706778                expr = _self_rule(*tmp) 
    707779                logger.warning("DEPRECATION WARNING: Using constraint rule with model argument last") 
    708             if expr is None or (type(expr) in (int, long, float) and expr == 0): 
     780            if expr is None: 
     781                logger.warning("DEPRECATION WARNING: Constraint rule returned None instead of ConstraintList.End") 
     782                break 
     783            if (expr.__class__ is tuple and expr == ConstraintList.End) or \ 
     784               (type(expr) in (int, long, float) and expr == 0): 
    709785                break 
    710786            self.add(expr) 
  • coopr.pyomo/trunk/coopr/pyomo/base/objective.py

    r4119 r4153  
    1 __all__ = ['Objective'] 
     1#  _________________________________________________________________________ 
     2# 
     3#  Coopr: A COmmon Optimization Python Repository 
     4#  Copyright (c) 2008 Sandia Corporation. 
     5#  This software is distributed under the BSD License. 
     6#  Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation, 
     7#  the U.S. Government retains certain rights in this software. 
     8#  For more information, see the Coopr README.txt file. 
     9#  _________________________________________________________________________ 
     10 
     11__all__ = ['Objective', 'simple_objective_rule'] 
    212 
    313import sys 
     
    2333 
    2434 
     35def simple_objective_rule( fn ): 
     36    """This is a decorator that translates None into Constraint.Skip. 
     37    This supports a simpler syntax in objective rules, though these can be 
     38    more difficult to debug when errors occur. 
     39 
     40    Example use: 
     41 
     42    @simple_objective_rule 
     43    def O_rule(model, i, j): 
     44        ... 
     45    """ 
     46 
     47    def wrapper_function ( *args, **kwargs ): 
     48        value = fn( *args, **kwargs ) 
     49        if value is None: 
     50            return Objective.Skip 
     51        return value 
     52    return wrapper_function 
     53 
     54 
     55 
    2556class ObjectiveData(NumericValue): 
    2657 
     
    84115    alias('Objective', 'Expressions that are minimized or maximized in a '    \ 
    85116          'model.') 
     117 
     118    Skip        = (1000,) 
     119    NoObjective = (1000,) 
    86120 
    87121    def __init__(self, *args, **kwargs): 
     
    193227            logger.warning("DEPRECATION WARNING: Using objective rule with model argument last") 
    194228        if tmp is None: 
    195             return None 
     229            logger.warning("DEPRECATION WARNING: Objective rule returned None instead of Objective.Skip") 
     230            return Objective.Skip 
    196231        if type(tmp) in [bool,int,long,float]: 
    197232            return NumericConstant(None,None,tmp) 
    198233        return tmp 
    199234 
    200  
    201235    def is_minimizing ( self ): 
    202236        return minimize == self.sense 
    203  
    204237 
    205238    def construct(self, data=None): 
     
    232265            if self._ndim==0: 
    233266                tmp = self._apply_rule(self.model, None) 
    234                 if tmp is not None and not (type(tmp) in (int,long,float)       \ 
    235                                             and tmp == 0): 
     267                self._data[None].label = label_from_name(self.name) 
     268                if not (tmp.__class__ is tuple and tmp == Objective.Skip): 
    236269                    self._data[None].expr = tmp 
    237                 self._data[None].label = label_from_name(self.name) 
    238270            else: 
    239271                _name=self.name 
    240272                for val in self._index: 
    241273                    tmp = self._apply_rule(self.model, val) 
    242                     if tmp is not None and not (type(tmp) in (int,long,float)     \ 
    243                                                 and tmp == 0): 
    244                         self._data[val] = ObjectiveData(expr=tmp, 
    245                                                        name=create_name(_name,val), obj=self) 
     274                    if not (tmp.__class__ is tuple and tmp == Objective.Skip): 
     275                        self._data[val] = ObjectiveData(expr=tmp, name=create_name(_name,val), obj=self) 
    246276                        self._data[val].index = val 
    247277            #self._index = self._data.keys() 
  • coopr.pyomo/trunk/coopr/pyomo/base/sets.py

    r4070 r4153  
    1010 
    1111__all__ = ['Set', '_BaseSet', '_SetContainer', '_SetArray', '_ProductSet', 
    12            'set_options'] 
     12           'set_options', 'simple_set_rule'] 
    1313import logging 
    1414import sys 
     
    4141        return func 
    4242    return decorator 
     43 
     44 
     45def simple_set_rule( fn ): 
     46    """This is a decorator that translates None into Set.End. 
     47    This supports a simpler syntax in set rules, though these can be 
     48    more difficult to debug when errors occur. 
     49 
     50    Example use: 
     51 
     52    @simple_set_rule 
     53    def A_rule(model, i, j): 
     54        ... 
     55    """ 
     56 
     57    def wrapper_function ( *args, **kwargs ): 
     58        value = fn( *args, **kwargs ) 
     59        if value is None: 
     60            return Set.End 
     61        return value 
     62    return wrapper_function 
    4363 
    4464 
     
    294314                    val = self.initialize(ctr, self.model) 
    295315                    logger.warning("DEPRECATION WARNING: Using set rule with model argument last") 
     316                if val is None: 
     317                    val = Set.End 
     318                    logger.warning("DEPRECATION WARNING: Set rule returned None instead of Set.Skip") 
    296319                if self.dimen is None: 
    297                     if type(val) in [tuple,list]: 
     320                    if type(val) in [tuple,list] and not val == Set.End: 
    298321                        self.dimen=len(val) 
    299322                    else: 
    300323                        self.dimen=1 
    301                 while val is not None: 
     324                while not (val.__class__ is tuple and val == Set.End): 
    302325                    self.add(val) 
    303326                    ctr += 1 
     
    307330                        val = self.initialize(ctr, self.model) 
    308331                        logger.warning("DEPRECATION WARNING: Using set rule with model argument last") 
     332                    if val is None: 
     333                        val = Set.End 
     334                        logger.warning("DEPRECATION WARNING: Set rule returned None instead of Set.Skip") 
    309335            # 
    310336            # We should be verifying as part of the add() method 
     
    946972                        val = self.initialize(*args) 
    947973                        logger.warning("DEPRECATION WARNING: Using set rule with model argument last") 
    948                     self.value[key].add( val ) 
    949                     while val is not None: 
     974                    if val is None: 
     975                        val = Set.End 
     976                        logger.warning("DEPRECATION WARNING: Set rule returned None instead of Set.Skip") 
     977                    if not (val.__class__ is tuple and val == Set.End): 
     978                        self.value[key].add( val ) 
     979                    while not (val.__class__ is tuple and val == Set.End): 
    950980                        self.value[key].add( val ) 
    951981                        ctr += 1 
     
    956986                            val = self.initialize(*args) 
    957987                            logger.warning("DEPRECATION WARNING: Using set rule with model argument last") 
     988                        if val is None: 
     989                            val = Set.End 
     990                            logger.warning("DEPRECATION WARNING: Set rule returned None instead of Set.Skip") 
    958991        # 
    959992        # Construct using the default values 
     
    11331166    alias('Set', "Set data that is used to define a model instance.") 
    11341167 
     1168    End             = (1003,) 
     1169 
    11351170    def __new__(cls, *args, **kwds): 
    11361171        if args == (): 
  • coopr.pyomo/trunk/coopr/pyomo/tests/unit/test_con.py

    r4119 r4153  
    551551        def f(model, i): 
    552552            if i%2 == 0: 
    553                 return None 
     553                return Constraint.Skip 
    554554            ans=0 
    555555            for j in model.x.keys(): 
     
    570570        def f(model, i): 
    571571            if i%2 == 0: 
    572                 return None 
     572                return Constraint.Skip 
    573573            ans=0 
    574574            for j in model.x.keys(): 
     
    585585        self.assertEqual(len(self.instance.c), 2) 
    586586 
    587     def test_dim(self): 
    588         """Test dim method""" 
    589         self.model.c = Constraint(self.model.A, noruleinit=True) 
    590         self.instance = self.model.create() 
    591         self.assertEqual(self.instance.c.dim(),1) 
    592  
    593     def test_keys(self): 
    594         """Test keys method""" 
    595         self.model.c = Constraint(self.model.A, noruleinit=True) 
    596         self.instance = self.model.create() 
    597         self.assertEqual(len(self.instance.c.keys()),0) 
    598  
    599     def test_len(self): 
    600         """Test len method""" 
    601         self.model.c = Constraint(self.model.A, noruleinit=True) 
    602         self.instance = self.model.create() 
    603         self.assertEqual(len(self.instance.c),0) 
    604         """Test rule option""" 
    605         def f(model): 
    606             ans=0 
    607             for i in model.x.keys(): 
    608                 ans = ans + model.x[i] 
    609             ans = ans==2 
    610             return ans 
    611         self.model.x = Var(RangeSet(1,4),initialize=2) 
    612         self.model.c = Constraint(rule=f) 
    613         self.instance = self.model.create() 
    614         self.assertEqual(len(self.instance.c),1) 
    615  
    616  
    617 class TestConList(PyomoModel): 
    618  
    619     def setUp(self): 
    620         # 
    621         # Create Model 
    622         # 
    623         PyomoModel.setUp(self) 
    624         self.model.A = Set(initialize=[1,2,3,4]) 
    625  
    626     def tearDown(self): 
    627         pass 
    628  
    629     def test_rule_option1(self): 
    630         """Test rule option""" 
     587    def test_rule_option2a(self): 
     588        """Test rule option""" 
     589        @simple_constraint_rule 
    631590        def f(model, i): 
    632             if i > 4: 
     591            if i%2 == 0: 
    633592                return None 
    634593            ans=0 
     
    640599            return ans 
    641600        self.model.x = Var(RangeSet(1,4),initialize=2) 
     601        self.model.c = Constraint(self.model.A,rule=f) 
     602        self.instance = self.model.create() 
     603        self.assertEqual(self.instance.c[1](), 8) 
     604        self.assertEqual(value(self.instance.c[1]), 8) 
     605        self.assertEqual(len(self.instance.c), 2) 
     606 
     607    def test_rule_option3a(self): 
     608        """Test rule option""" 
     609        @simple_constraint_rule 
     610        def f(model, i): 
     611            if i%2 == 0: 
     612                return None 
     613            ans=0 
     614            for j in model.x.keys(): 
     615                ans = ans + model.x[j] 
     616            ans *= i 
     617            ans = ans < 0 
     618            ans = ans > 0 
     619            return ans 
     620        self.model.x = Var(RangeSet(1,4),initialize=2) 
     621        self.model.c = Constraint(self.model.A,rule=f) 
     622        self.instance = self.model.create() 
     623        self.assertEqual(self.instance.c[1](), 8) 
     624        self.assertEqual(value(self.instance.c[1]), 8) 
     625        self.assertEqual(len(self.instance.c), 2) 
     626 
     627    def test_dim(self): 
     628        """Test dim method""" 
     629        self.model.c = Constraint(self.model.A, noruleinit=True) 
     630        self.instance = self.model.create() 
     631        self.assertEqual(self.instance.c.dim(),1) 
     632 
     633    def test_keys(self): 
     634        """Test keys method""" 
     635        self.model.c = Constraint(self.model.A, noruleinit=True) 
     636        self.instance = self.model.create() 
     637        self.assertEqual(len(self.instance.c.keys()),0) 
     638 
     639    def test_len(self): 
     640        """Test len method""" 
     641        self.model.c = Constraint(self.model.A, noruleinit=True) 
     642        self.instance = self.model.create() 
     643        self.assertEqual(len(self.instance.c),0) 
     644        """Test rule option""" 
     645        def f(model): 
     646            ans=0 
     647            for i in model.x.keys(): 
     648                ans = ans + model.x[i] 
     649            ans = ans==2 
     650            return ans 
     651        self.model.x = Var(RangeSet(1,4),initialize=2) 
     652        self.model.c = Constraint(rule=f) 
     653        self.instance = self.model.create() 
     654        self.assertEqual(len(self.instance.c),1) 
     655 
     656 
     657class TestConList(PyomoModel): 
     658 
     659    def setUp(self): 
     660        # 
     661        # Create Model 
     662        # 
     663        PyomoModel.setUp(self) 
     664        self.model.A = Set(initialize=[1,2,3,4]) 
     665 
     666    def tearDown(self): 
     667        pass 
     668 
     669    def test_rule_option1(self): 
     670        """Test rule option""" 
     671        def f(model, i): 
     672            if i > 4: 
     673                return ConstraintList.End 
     674            ans=0 
     675            for j in model.x.keys(): 
     676                ans = ans + model.x[j] 
     677            ans *= i 
     678            ans = ans < 0 
     679            ans = ans > 0 
     680            return ans 
     681        self.model.x = Var(RangeSet(1,4),initialize=2) 
    642682        self.model.c = ConstraintList(rule=f) 
    643683        self.instance = self.model.create() 
     
    650690    def test_rule_option2(self): 
    651691        """Test rule option""" 
     692        def f(model, i): 
     693            if i > 2: 
     694                return ConstraintList.End 
     695            i = 2*i - 1 
     696            ans=0 
     697            for j in model.x.keys(): 
     698                ans = ans + model.x[j] 
     699            ans *= i 
     700            ans = ans < 0 
     701            ans = ans > 0 
     702            return ans 
     703        self.model.x = Var(RangeSet(1,4),initialize=2) 
     704        self.model.c = ConstraintList(rule=f) 
     705        self.instance = self.model.create() 
     706        self.assertEqual(self.instance.c[1](), 8) 
     707        self.assertEqual(value(self.instance.c[1]), 8) 
     708        self.assertEqual(len(self.instance.c), 2) 
     709 
     710    def test_rule_option1a(self): 
     711        """Test rule option""" 
     712        @simple_constraintlist_rule 
     713        def f(model, i): 
     714            if i > 4: 
     715                return None 
     716            ans=0 
     717            for j in model.x.keys(): 
     718                ans = ans + model.x[j] 
     719            ans *= i 
     720            ans = ans < 0 
     721            ans = ans > 0 
     722            return ans 
     723        self.model.x = Var(RangeSet(1,4),initialize=2) 
     724        self.model.c = ConstraintList(rule=f) 
     725        self.instance = self.model.create() 
     726        self.assertEqual(self.instance.c[1](), 8) 
     727        self.assertEqual(self.instance.c[2](), 16) 
     728        self.assertEqual(value(self.instance.c[1]), 8) 
     729        self.assertEqual(value(self.instance.c[2]), 16) 
     730        self.assertEqual(len(self.instance.c), 4) 
     731 
     732    def test_rule_option2a(self): 
     733        """Test rule option""" 
     734        @simple_constraintlist_rule 
    652735        def f(model, i): 
    653736            if i > 2: 
     
    779862    def test_rule(self): 
    780863        def rule1(model): 
    781             return None 
     864            return Constraint.Skip 
    782865        model=AbstractModel() 
    783866        model.o = Constraint(rule=rule1) 
     
    798881        # 
    799882        def rule1(model, i): 
    800             return None 
     883            return Constraint.Skip 
    801884        model=AbstractModel() 
    802885        model.a=Set(initialize=[1,2,3]) 
  • coopr.pyomo/trunk/coopr/pyomo/tests/unit/test_obj.py

    r4119 r4153  
    142142        pass 
    143143 
    144     def test_rule_option(self): 
     144    def test_rule_option1(self): 
    145145        """Test rule option""" 
    146146        def f(model, i): 
     
    156156        self.assertEqual(self.instance.obj[2](), 16) 
    157157        self.assertEqual(value(self.instance.obj[1]), 8) 
     158        self.assertEqual(value(self.instance.obj[2]), 16) 
     159 
     160    def test_rule_option2(self): 
     161        """Test rule option""" 
     162        def f(model, i): 
     163            if i == 1: 
     164                return Objective.Skip 
     165            ans=0 
     166            for j in model.x.keys(): 
     167                ans = ans + model.x[j] 
     168            ans *= i 
     169            return ans 
     170        self.model.x = Var(RangeSet(1,4),initialize=2) 
     171        self.model.obj = Objective(self.model.A,rule=f) 
     172        self.instance = self.model.create() 
     173        self.assertEqual(self.instance.obj[2](), 16) 
     174        self.assertEqual(value(self.instance.obj[2]), 16) 
     175 
     176    def test_rule_option3(self): 
     177        """Test rule option""" 
     178        @simple_objective_rule 
     179        def f(model, i): 
     180            if i == 1: 
     181                return None 
     182            ans=0 
     183            for j in model.x.keys(): 
     184                ans = ans + model.x[j] 
     185            ans *= i 
     186            return ans 
     187        self.model.x = Var(RangeSet(1,4),initialize=2) 
     188        self.model.obj = Objective(self.model.A,rule=f) 
     189        self.instance = self.model.create() 
     190        self.assertEqual(self.instance.obj[2](), 16) 
    158191        self.assertEqual(value(self.instance.obj[2]), 16) 
    159192 
     
    208241        pass 
    209242 
    210     def test_rule_option(self): 
     243    def test_rule_option1(self): 
    211244        """Test rule option""" 
    212245        def f(model, i, k): 
     
    313346    def test_rule(self): 
    314347        def rule1(model): 
    315             return None 
     348            return [] 
    316349        model=AbstractModel() 
    317350        model.o = Objective(rule=rule1) 
  • coopr.pyomo/trunk/coopr/pyomo/tests/unit/test_set.py

    r4119 r4153  
    16371637        print >>OUTPUT, "data; param n := 5; end;" 
    16381638        OUTPUT.close() 
     1639        @simple_set_rule 
    16391640        def tmp_init(model, z): 
    16401641            if z>value(model.n) or z == 11: 
     
    16461647        self.assertEqual(len(self.instance.A),5) 
    16471648 
     1649    def test_rule3(self): 
     1650        # 
     1651        # Create model instance 
     1652        # 
     1653        OUTPUT=open(currdir+"setA.dat","w") 
     1654        print >>OUTPUT, "data; param n := 5; end;" 
     1655        OUTPUT.close() 
     1656        def tmp_init(model, z): 
     1657            if z>value(model.n) or z == 11: 
     1658                return Set.End 
     1659            return z 
     1660        self.model.n = Param() 
     1661        self.model.A = Set(initialize=tmp_init) 
     1662        self.instance = self.model.create(currdir+"setA.dat") 
     1663        self.assertEqual(len(self.instance.A),5) 
     1664 
    16481665    def test_within1(self): 
    16491666        # 
     
    18491866        print >>OUTPUT, "data; param n := 5; set Z := A C; end;" 
    18501867        OUTPUT.close() 
    1851         def tmp_init(model, z, i): 
     1868        @simple_set_rule 
     1869        def tmp_rule2(model, z, i): 
    18521870            if z>value(model.n): 
    18531871                return None 
     
    18551873        self.model.n = Param() 
    18561874        self.model.Z = Set() 
    1857         self.model.A = Set(self.model.Z, initialize=tmp_init) 
     1875        self.model.A = Set(self.model.Z, initialize=tmp_rule2) 
     1876        self.instance = self.model.create(currdir+"setA.dat") 
     1877        self.assertEqual(len(self.instance.A['A']),5) 
     1878 
     1879    def test_rule3(self): 
     1880        # 
     1881        # Create Set 'A' data file 
     1882        # 
     1883        OUTPUT=open(currdir+"setA.dat","w") 
     1884        print >>OUTPUT, "data; param n := 5; set Z := A C; end;" 
     1885        OUTPUT.close() 
     1886        def tmp_rule2(model, z, i): 
     1887            if z>value(model.n): 
     1888                return Set.End 
     1889            return z 
     1890        self.model.n = Param() 
     1891        self.model.Z = Set() 
     1892        self.model.A = Set(self.model.Z, initialize=tmp_rule2) 
    18581893        self.instance = self.model.create(currdir+"setA.dat") 
    18591894        self.assertEqual(len(self.instance.A['A']),5) 
  • coopr.pyomo/trunk/examples/pyomo/tutorials/set.py

    r4119 r4153  
    173173def U_init(model, z): 
    174174    if z==6: 
    175         return None 
     175        return Set.End 
    176176    if z==1: 
    177177        return 1 
     
    188188def V_init(model, z, i): 
    189189    if z==6: 
    190         return None 
     190        return Set.End 
    191191    if i==1: 
    192192        if z==1: 
Note: See TracChangeset for help on using the changeset viewer.