Changeset 2214


Ignore:
Timestamp:
Jan 31, 2010 4:44:12 PM (10 years ago)
Author:
wehart
Message:

Reworking the canonical expression definition to include a
dictionary from variable ID -> _VarValue object.

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

Legend:

Unmodified
Added
Removed
  • coopr.pyomo/trunk/coopr/pyomo/expr/canonical_repn.py

    r2201 r2214  
    3232
    3333
    34 def as_expr(rep, model, ignore_other=False):
     34def as_expr(rep, vars=None, model=None, ignore_other=False):
    3535    """ Convert a canonical representation into an expression. """
    3636    if isinstance(model, Model):
    3737        vars = model._var
    3838        id_offset=0
    39     else:
    40         vars = model
     39    elif not vars is None:
    4140        id_offset=1
    4241    expr = 0.0
     
    4544            if not ignore_other:
    4645                expr += rep[d]
     46            continue
     47        if d is -1:
    4748            continue
    4849        for v in rep[d]:
     
    5354            for id in v:
    5455                for i in xrange(v[id]):
    55                     e *= vars[id+id_offset]
     56                    if vars is None:
     57                        e *= rep[-1][id]
     58                    else:
     59                        e *= vars[id[1]+id_offset]
    5660            expr += e
    5761    return expr
     
    6670                rep[d] = r2[d]
    6771            continue
     72        if d < 0:
     73            continue
    6874        if not d in rep:
    6975            rep[d] = {}
    7076        for var in r2[d]:
    7177            rep[d][var] = coef*r2[d][var] + rep[d].get(var,0.0)
     78    #
     79    # Merge the VarValue maps
     80    #
     81    if -1 in r2:
     82        if -1 in rep:
     83            rep[-1].update(r2[-1])
     84        else:
     85            rep[-1] = r2[-1]
    7286    return rep
    7387
    7488
    75 def repn_mult(r1, r2, model, coef=1.0):
     89def repn_mult(r1, r2, coef=1.0):
    7690    rep = {}
    7791    for d1 in r1:
    7892        for d2 in r2:
    79             if d1 == None or d2 == None:
     93            if d1 == None or d2 == None or d1 < 0 or d2 < 0:
    8094                pass
    8195            else:
     
    105119    #
    106120    if None in r1:
    107         rep[None] = as_expr(r2, model, ignore_other=True) * copy.deepcopy(r1[None])
    108         #print "YY"
    109         #r1[None].pprint()
    110         #as_expr(r2, model, ignore_other=True).pprint()
    111         #print "YY"
     121        rep[None] = as_expr(r2, ignore_other=True) * copy.deepcopy(r1[None])
    112122        if None in r2:
    113123            rep[None] += copy.deepcopy(r1[None])*copy.deepcopy(r2[None])
    114124    if None in r2:
    115125        if None in rep:
    116             rep[None] += as_expr(r1, model, ignore_other=True) * copy.deepcopy(r2[None])
    117         else:
    118             rep[None]  = as_expr(r1, model, ignore_other=True) * copy.deepcopy(r2[None])
     126            rep[None] += as_expr(r1, ignore_other=True) * copy.deepcopy(r2[None])
     127        else:
     128            rep[None]  = as_expr(r1, ignore_other=True) * copy.deepcopy(r2[None])
     129    #
     130    # Merge the VarValue maps
     131    #
     132    if -1 in r1:
     133        rep[-1] = r1[-1]
     134    if -1 in r2:
     135        if -1 in rep:
     136            rep[-1].update(r2[-1])
     137        else:
     138            rep[-1] = r2[-1]
    119139    #
    120140    # Return the canonical repn
     
    134154# called recursively.
    135155#
    136 def collect_canonical_repn(exp, model):
     156def collect_canonical_repn(exp):
    137157    global temp_const
    138158    global temp_var
     
    156176                repn = {}
    157177            for i in range(len(exp._args)):
    158                 repn = repn_add(repn, collect_canonical_repn(exp._args[i], model), coef=exp._coef[i] )
     178                repn = repn_add(repn, collect_canonical_repn(exp._args[i]), coef=exp._coef[i] )
    159179            return repn
    160180        #
     
    186206            #print "Y",exp.coef/denom
    187207            for e in exp._numerator:
    188                 repn = repn_mult(repn, collect_canonical_repn(e, model), model)
     208                repn = repn_mult(repn, collect_canonical_repn(e))
    189209            return repn
    190210        #
     
    203223    #
    204224    elif type(exp) is _VarValue or exp.type() is Var:
    205         temp_var = { 1: {frozendict({exp.id:1}):1.0} }   
     225        if type(exp) is _VarValue:
     226            mid = id(exp.var.model)
     227        else:
     228            mid = id(exp.model)
     229        temp_var = { -1: {(mid,exp.id):exp}, 1: {frozendict({(mid,exp.id):1}):1.0} }   
    206230        return temp_var
    207231    #
     
    232256# log(y[1]) + x[1]*x[1]         {2:{{0:2}:1.0}, None:log(y[1])}
    233257#
    234 def generate_canonical_repn(expr, model):
    235     return collect_canonical_repn(expr, model)
     258def generate_canonical_repn(expr):
     259    return collect_canonical_repn(expr)
    236260
    237261def is_constant(repn):
    238262    """Return True if the canonical representation is a constant expression"""
    239     return (0 in repn) and (len(repn) == 1)
     263    for key in repn:
     264        if key is None or key > 0:
     265            return False
     266    return True
    240267
    241268def is_nonlinear(repn):
    242269    """Return True if the canonical representation is a nonlinear expression"""
    243270    for key in repn:
    244         if not key in [0,1]:
     271        if not key in [-1,0,1]:
    245272            return True
    246273    return False
  • coopr.pyomo/trunk/coopr/pyomo/io/cpxlp.py

    r2211 r2214  
    8989        return a[0]
    9090
    91     def _print_expr(self, model, x, OUTPUT, print_offset=False):
     91    def _print_expr(self, x, OUTPUT, print_offset=False):
    9292        max_terms_on_line=5 # this is the line-limit hack
    9393        terms_output = 0
     
    100100            for id in keys:
    101101                coef = x[1][id]
    102                 name = convert_name(model._var[id.keys()[0]].label)
     102                name = convert_name(x[-1][id.keys()[0]].label)
    103103                print >>OUTPUT, ('- %f' % math.fabs(coef) if coef < 0.0 else '+ %f' % coef), name,
    104104                terms_output += 1
     
    117117                print >>OUTPUT, ('- %f' % math.fabs(coef) if coef < 0.0 else '+ %f' % coef),
    118118                for var in id:
    119                     name = convert_name(model._var[var].label)
     119                    name = convert_name(x[-1][var].label)
    120120                    if id[var] > 1:
    121121                        print "%s^%d" % (name,id[var]),
     
    228228                if is_nonlinear(obj[key].repn) and not is_quadratic(obj[key].repn):
    229229                    raise ValueError, "Cannot write legal LP file.  Objective %s[%s] has nonlinear terms that are not quadratic." % (str(obj),str(key))
    230                 self._print_expr(model, obj[key].repn, OUTPUT, print_offset=True)
     230                self._print_expr(obj[key].repn, OUTPUT, print_offset=True)
    231231           if obj._quad_subexpr is not None:
    232232               self._print_quadterm(obj._quad_subexpr, (_obj[ _obj.keys()[0] ].sense == minimize), OUTPUT)
     
    283283                         #
    284284                         print >>OUTPUT, prefix + "c_e_" + convert_name(C._data[cndx].label) + "_: ",
    285                          offset = self._print_expr(model, C[cndx].repn, OUTPUT)
     285                         offset = self._print_expr(C[cndx].repn, OUTPUT)
    286286                         print >>OUTPUT, "=",
    287287                         self._print_bound(C._data[cndx].lower, OUTPUT, -offset)
     
    294294                         if C._data[cndx].lower is not None:
    295295                            print >>OUTPUT, prefix + "c_l_" + convert_name(C._data[cndx].label) + "_: ",
    296                             offset = self._print_expr(model, C[cndx].repn, OUTPUT)
     296                            offset = self._print_expr(C[cndx].repn, OUTPUT)
    297297                            print >>OUTPUT, ">=",
    298298                            self._print_bound(C._data[cndx].lower, OUTPUT, -offset)
     
    301301                         if C._data[cndx].upper is not None:
    302302                            print >>OUTPUT, prefix + "c_u_" + convert_name(C._data[cndx].label) + "_: ",
    303                             offset = self._print_expr(model, C[cndx].repn, OUTPUT)
     303                            offset = self._print_expr(C[cndx].repn, OUTPUT)
    304304                            print >>OUTPUT, "<=",
    305305                            self._print_bound(C._data[cndx].upper, OUTPUT, -offset)
  • coopr.pyomo/trunk/coopr/pyomo/presolve/compute_canonical_repn.py

    r2201 r2214  
    5353                    raise ValueError, "No expression has been defined for objective %s" % str(key)
    5454                try:
    55                     obj._data[ondx].repn = coopr.pyomo.expr.generate_canonical_repn(obj._data[ondx].expr, model)
     55                    obj._data[ondx].repn = coopr.pyomo.expr.generate_canonical_repn(obj._data[ondx].expr)
    5656                except Exception, e:
    5757                    print "Error generating a canonical representation for objective %s (index %s)" % (str(key), str(ondx))
     
    7575                    raise ValueError, "No expression has been defined for the body of constraint %s" % str(key)
    7676                try:                 
    77                     con._data[cndx].repn = coopr.pyomo.expr.generate_canonical_repn(con._data[cndx].body, model)
     77                    con._data[cndx].repn = coopr.pyomo.expr.generate_canonical_repn(con._data[cndx].body)
    7878                except Exception, e:
    7979                    print "Error generating a canonical representation for constraint %s (index %s)" % (str(key), str(cndx))
  • coopr.pyomo/trunk/coopr/pyomo/tests/expr/test_canonical.py

    r2201 r2214  
    6464        self.instance = self.model.create()
    6565        #self.instance.obj[None].expr.pprint()
    66         self.failUnlessEqual(generate_canonical_repn(self.instance.obj[None].expr, self.instance), {1: {frozendict({2: 1}): 6.0, frozendict({1: 1}): 4.0, frozendict({3: 1}): 8.0, frozendict({0: 1}): 2.0}})
     66        mid=id(self.instance)
     67        rep = generate_canonical_repn(self.instance.obj[None].expr)
     68        del rep[-1]
     69        self.failUnlessEqual(rep, {1: {frozendict({(mid,2): 1}): 6.0, frozendict({(mid,1): 1}): 4.0, frozendict({(mid,3): 1}): 8.0, frozendict({(mid,0): 1}): 2.0}})
    6770
    6871    def test_expr2(self):
     
    7679        self.model.obj = Objective(rule=obj_rule)
    7780        self.instance = self.model.create()
    78         #self.instance.obj[None].expr.pprint()
    79         self.failUnlessEqual(generate_canonical_repn(self.instance.obj[None].expr, self.instance), {1: {frozendict({2: 1}): 6.0, frozendict({1: 1}): 4.0, frozendict({3: 1}): 8.0, frozendict({0: 1}): 2.0}})
     81        mid=id(self.instance)
     82        #self.instance.obj[None].expr.pprint()
     83        rep = generate_canonical_repn(self.instance.obj[None].expr)
     84        del rep[-1]
     85        self.failUnlessEqual(rep, {1: {frozendict({(mid,2): 1}): 6.0, frozendict({(mid,1): 1}): 4.0, frozendict({(mid,3): 1}): 8.0, frozendict({(mid,0): 1}): 2.0}})
    8086
    8187    def test_expr3(self):
     
    8995        self.model.obj = Objective(rule=obj_rule)
    9096        self.instance = self.model.create()
    91         #self.instance.obj[None].expr.pprint()
    92         self.failUnlessEqual(generate_canonical_repn(self.instance.obj[None].expr, self.instance),
    93                     {1: {frozendict({0: 1}):9.0, frozendict({1: 1}):4.0}})
     97        mid=id(self.instance)
     98        #self.instance.obj[None].expr.pprint()
     99        rep = generate_canonical_repn(self.instance.obj[None].expr)
     100        del rep[-1]
     101        self.failUnlessEqual(rep,
     102                    {1: {frozendict({(mid,0): 1}):9.0, frozendict({(mid,1): 1}):4.0}})
    94103
    95104    def test_expr4(self):
     
    103112        self.model.obj = Objective(rule=obj_rule)
    104113        self.instance = self.model.create()
    105         #self.instance.obj[None].expr.pprint()
    106         self.failUnlessEqual(generate_canonical_repn(self.instance.obj[None].expr, self.instance), {0:frozendict({None:1.2}), 1: {frozendict({0: 1}): 5.0}})
     114        mid=id(self.instance)
     115        #self.instance.obj[None].expr.pprint()
     116        rep = generate_canonical_repn(self.instance.obj[None].expr)
     117        del rep[-1]
     118        self.failUnlessEqual(rep, {0:frozendict({None:1.2}), 1: {frozendict({(mid,0): 1}): 5.0}})
    107119
    108120    def test_expr5(self):
     
    116128        self.model.obj = Objective(rule=obj_rule)
    117129        self.instance = self.model.create()
    118         #self.instance.obj[None].expr.pprint()
    119         self.failUnlessEqual(generate_canonical_repn(self.instance.obj[None].expr, self.instance),
    120                 {2: {frozendict({0:2}):1.0, frozendict({0:1, 1:1}):2.0}, 3:{frozendict({1:1,2:2}):3.0}})
     130        mid=id(self.instance)
     131        #self.instance.obj[None].expr.pprint()
     132        rep = generate_canonical_repn(self.instance.obj[None].expr)
     133        del rep[-1]
     134        self.failUnlessEqual(rep,
     135                {2: {frozendict({(mid,0):2}):1.0, frozendict({(mid,0):1, (mid,1):1}):2.0}, 3:{frozendict({(mid,1):1, (mid,2):2}):3.0}})
    121136
    122137    def test_expr6(self):
     
    130145        self.model.obj = Objective(rule=obj_rule)
    131146        self.instance = self.model.create()
    132         #self.instance.obj[None].expr.pprint()
    133         self.failUnlessEqual(generate_canonical_repn(self.instance.obj[None].expr, self.instance),
    134             {0:frozendict({None:5.4}), 1: {frozendict({0: 1}): 13.0}})
     147        mid=id(self.instance)
     148        #self.instance.obj[None].expr.pprint()
     149        rep = generate_canonical_repn(self.instance.obj[None].expr)
     150        del rep[-1]
     151        self.failUnlessEqual(rep,
     152            {0:frozendict({None:5.4}), 1: {frozendict({(mid,0): 1}): 13.0}})
    135153
    136154    def test_expr7(self):
     
    144162        self.model.obj = Objective(rule=obj_rule)
    145163        self.instance = self.model.create()
    146         #self.instance.obj[None].expr.pprint()
    147         self.failUnlessEqual(generate_canonical_repn(self.instance.obj[None].expr, self.instance),
    148             {1: {frozendict({2: 1}): 3.0, frozendict({1: 1}): 2.0, frozendict({3: 1}): 4.0, frozendict({0: 1}): 1.0}})
     164        mid=id(self.instance)
     165        #self.instance.obj[None].expr.pprint()
     166        rep = generate_canonical_repn(self.instance.obj[None].expr)
     167        del rep[-1]
     168        self.failUnlessEqual(rep,
     169            {1: {frozendict({(mid,2): 1}): 3.0, frozendict({(mid,1): 1}): 2.0, frozendict({(mid,3): 1}): 4.0, frozendict({(mid,0): 1}): 1.0}})
    149170
    150171    def test_expr8(self):
     
    161182        self.instance.y.fixed = True
    162183        self.instance.y.reset()
    163         #self.instance.obj[None].expr.pprint()
    164         self.failUnlessEqual(generate_canonical_repn(self.instance.obj[None].expr, self.instance),
    165             {1: {frozendict({2: 1}): 3.0, frozendict({1: 1}): 2.0, frozendict({3: 1}): 4.0, frozendict({0: 1}): 1.0}})
     184        mid=id(self.instance)
     185        #self.instance.obj[None].expr.pprint()
     186        rep = generate_canonical_repn(self.instance.obj[None].expr)
     187        del rep[-1]
     188        self.failUnlessEqual(rep,
     189            {1: {frozendict({(mid,2): 1}): 3.0, frozendict({(mid,1): 1}): 2.0, frozendict({(mid,3): 1}): 4.0, frozendict({(mid,0): 1}): 1.0}})
    166190
    167191    def test_expr9(self):
     
    178202        self.instance.y.fixed = True
    179203        self.instance.y.reset()
    180         #self.instance.obj[None].expr.pprint()
    181         self.failUnlessEqual(generate_canonical_repn(self.instance.obj[None].expr, self.instance),
    182             {1: {frozendict({2: 1}): 3.0, frozendict({1: 1}): 2.0, frozendict({3: 1}): 4.0, frozendict({0: 1}): 1.0}})
     204        mid=id(self.instance)
     205        #self.instance.obj[None].expr.pprint()
     206        rep = generate_canonical_repn(self.instance.obj[None].expr)
     207        del rep[-1]
     208        self.failUnlessEqual(rep,
     209            {1: {frozendict({(mid,2): 1}): 3.0, frozendict({(mid,1): 1}): 2.0, frozendict({(mid,3): 1}): 4.0, frozendict({(mid,0): 1}): 1.0}})
    183210
    184211    def test_expr10(self):
     
    194221        self.instance = self.model.create()
    195222        #self.instance.obj[None].expr.pprint()
    196         rep = generate_canonical_repn(self.instance.obj[None].expr, self.instance)
     223        rep = generate_canonical_repn(self.instance.obj[None].expr)
    197224        self.failUnless(len(rep) == 1 and None in rep)
    198225
     
    209236        self.instance = self.model.create()
    210237        #self.instance.obj[None].expr.pprint()
    211         rep = generate_canonical_repn(self.instance.obj[None].expr, self.instance)
     238        rep = generate_canonical_repn(self.instance.obj[None].expr)
    212239        rep[None].pprint()
    213240        del rep[None]
    214         self.failUnlessEqual(rep, {0: {None: 3.0}, 1: {frozendict({1: 1}): 1.0, frozendict({0: 1}): 1.0}})
     241        del rep[-1]
     242        mid=id(self.instance)
     243        self.failUnlessEqual(rep, {0: {None: 3.0}, 1: {frozendict({(mid,1): 1}): 1.0, frozendict({(mid,0): 1}): 1.0}})
    215244
    216245    def test_expr12(self):
     
    225254        self.model.obj = Objective(rule=obj_rule)
    226255        self.instance = self.model.create()
    227         #self.instance.obj[None].expr.pprint()
    228         rep = generate_canonical_repn(self.instance.obj[None].expr, self.instance)
     256        mid=id(self.instance)
     257        #self.instance.obj[None].expr.pprint()
     258        rep = generate_canonical_repn(self.instance.obj[None].expr)
    229259        rep[None].pprint()
    230260        del rep[None]
    231         self.failUnlessEqual(rep, {0: {None: 2.0}, 1: {frozendict({1: 1}): 1.0, frozendict({0: 1}): 2.0}, 2: {frozendict({0: 1, 1: 1}): 1.0}})
     261        del rep[-1]
     262        self.failUnlessEqual(rep, {0: {None: 2.0}, 1: {frozendict({(mid,1): 1}): 1.0, frozendict({(mid,0): 1}): 2.0}, 2: {frozendict({(mid,0): 1, (mid,1): 1}): 1.0}})
    232263
    233264if __name__ == "__main__":
Note: See TracChangeset for help on using the changeset viewer.