#**************************************************************************
#Copyright (C) 2009 Yingjie Lan, ylan@umd.edu

#This file is part of PyMathProg.

#PyMathProg is free software; you can redistribute it and/or modify
#it under the terms of the GNU General Public License as published by
#the Free Software Foundation; either version 3 of the License, or
#(at your option) any later version.

#PyMathProg is distributed in the hope that it will be useful,
#but WITHOUT ANY WARRANTY; without even the implied warranty of
#MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
#GNU General Public License for more details.

#You should have received a copy of the GNU General Public License
#along with PyMathProg. If not, see <http://www.gnu.org/licenses/>.
#**************************************************************************

def pymprog_version():
    return "pymprog 0.4.2"

def extract_keys(kd, kt):
    ed = {}
    for key in kt:
        if key in kd: 
           ed[key]=kd[key]
    return ed

#import glpk
from glpk import LPX
from glpk import env

_pyglpk_version_incompat = """
pyglpk version  incompatible!
Please get the latest version of pyglpk from
http://sourceforge.net/projects/pymprog/"""

try:
   from glpk import pyglpk_version
except: 
   raise Exception, _pyglpk_version_incompat
   
if pyglpk_version < '0.3.2':
   raise Exception, _pyglpk_version_incompat

#keep a GLOBAL list of models:
#only for implementation of the global interface.
_models = []

#Global interface:
#This allows one to create, manipulate, solve
#A model without explicitly deal with a model instance.
#Rather, the package manages the model instance.

def beginModel(name=None):
   """Start a model to work with."""
   prob = model(name)
   _models.insert(0,prob)

def endModel():
   """Finish with a model, model instance is returned."""
   return _models.pop(0)

def verbose(v):
   """Report what's going on."""
   _models[0].verb = v

def listmod():
   print "models (first is current):"
   for p in _models:
      print p.name, p

def st(cons, name=None, inds=None):
   """Create new constraints."""
   prob = _models[0]
   return prob.st(cons, name, inds)

def minimize(obj, name=None):
   """Create a minimizing objective."""
   prob = _models[0]
   prob.min(obj, name)

def maximize(obj, name=None):
   """Create a maximizing objective."""
   prob = _models[0]
   prob.max(obj, name)

def var(inds=None, name=None, kind=None, bounds=None):
   """Create variables over the given indices.
      you can optionally specify variable name,
      kind (default is float, other values: int, bool.
      bounds (default: (0, None) -- None = infinity)"""
   prob = _models[0]
   return prob.var(inds, name, kind, bounds)

def par(val, name=None):
   """Create parameters. the returned parameter
container has the same structure and index as 
the passed in values."""
   prob = _models[0]
   return prob.par(val, name)

def solve(t=None):
   """Solve the model, return solver status."""
   prob = _models[0]
   return prob.solve(t)

def solveMIP():
   """Solve the model using only MIP methods,
assuming you have solved the LP relaxation.
return solver status."""
   prob = _models[0]
   return prob.solveMIP()

def status():
   """obtain the status of the solver."""
   prob = _models[0]
   return prob.status()

def kkt(kind=None):
   """Karush-Kuhn-Tucker optimality conditions for 
1. a basic (simplex) solution if kind = float.  
   If the argument 'scaled' is true, return results
   of checking the internal scaled instance of the LP instead.
2. a mixed-integer solution if kind = int.  
   Note that only the primal components
   of the KKT object will have meaningful values.
"""
   prob = _models[0]
   return prob.kkt(kind)

def reportKKT(kind=None):
   """produce a convenient report on KKT"""
   prob = _models[0]
   return prob.reportKKT(kind)

def vobj():
   """obtain the objective value."""
   prob = _models[0]
   return prob.vobj()

def solvopt(**kwds):
   """add/get/del solver options. 
Only accept keyword arguments.
add: solvopt(method='exact');
get: solvopt();
del: solvopt(method=None);"""
   prob = _models[0]
   return prob.solvopt(**kwds)

def evaluate(expr):
   """return the value of an expression
when all its variables take their primal values."""
   return expr.evaluate() if isinstance(expr, parex)\
      else expr.primal if isinstance(expr, variable)\
      else expr.value if isinstance(expr, param)\
      else expr #unchanged

def sensit(file_name):
   """write sensitivity analysis report to a file"""
   prob = _models[0]
   prob.sensit(file_name)

def write(**kwds):
   """write specific information to files."""
   prob = _models[0]
   prob.write(**kwds)
   
####### Class Definitions ####

#below is how to do mixed indexing with dictionary
# x = {(3,'h'):6, (5,'k'):5}
# x[3,'h']

class iprod(object): 
   """index product: given a list/tuple of sets, 
   enumerate all combinations as tuples."""
   def __init__(self, *args): 
      self._llist =  args
      self._sofar = []

   def __iter__(self): 
      return self.next() 

   def next(self): 
      for idx in self._llist[len(self._sofar)]:
         self._sofar.append(idx)
         if len(self._sofar)==len(self._llist):
            yield tuple(self._sofar)
         else:
            for v in self.next(): yield v
         self._sofar.pop()

   def __len__(self):
       ret = 1
       for i in self._llist: ret *= len(i)
       return ret

class model(object):
   """this object holds an glpk.LPX() object.
    you can retrieve it by the "solver()" method.
    for how to use that object to solve models,
    you can refer to PyGLPK documentation.
    Once the model is solved, you can access
    the results via that object. You can also 
    access the solution by the variables created
    via the "var()" method, or find out the 
    status of the constraints by the constraints
    created by the "st()" method."""
   def __init__(me, name):
      me.p = LPX()
      me.p.name = name
      me.grid = 0 #group row id
      me.gcid = 0 #group col id
      me.gpid = 0 #group par id
      me.verb = False
      me.options = {} #solver options


   def var(me, inds=None, name=None, kind=None, bounds=None):
      if name==None:
         name = "X%d"%me.gcid
         me.gcid += 1
      if inds==None:
         idx = me.p.cols.add(1)
         return variable(me.p.cols[idx], name, kind, bounds) 
      #create many variables as a dict.
      vars = {}
      for t in inds: vars[t] = None
      idx = me.p.cols.add(len(vars))
      name += "[%s]"
      for t in inds:
         vars[t] = variable(me.p.cols[idx], 
            name%str(t), kind, bounds)
         idx += 1
      return vars

   def par(me, val, name=None):
      if name==None:
         name = "P%d"%me.gpid
         me.gpid += 1
      if type(val) in (int, long, float, str):
         return param(val, name)
      if type(val) in (list, tuple):
         return [me.par(v, "%s[%d]"%(name,i)) for 
           v,i in zip(val, range(len(val)))]
      if type(val) == dict: 
         pp = {}; name += "[%s]"
         for t in val: 
            pp[t] = me.par(val[t], name%str(t))
         return pp
      #assume to be something iterable (generator, set, ...):
      #however, if v is a string, umlimited recursion results
      return me.par([v for v in val], name) 

   def st(me, cons, name=None, inds=None):
      """subject to: add one or many constraints"""
      if name==None: 
         name="R%d"%me.grid
         me.grid += 1
      if type(cons) in (constraint, variable): 
            idx = me.p.rows.add(1)
            cons = cons.bind(me.p.rows[idx], name)
            if me.verb: print cons
            return cons
      cons = [t for t in cons] #copy
      if not cons: return cons #empty
      coni = xrange(len(cons))
      if inds==None: inds = xrange(len(cons))
      #create many constraints
      name += "[%s]"
      idx = me.p.rows.add(len(cons))
      for t, i in zip(inds, coni):
         cons[i] = cons[i].bind(me.p.rows[idx], name%str(t))
         if me.verb: print cons[i]
         idx += 1
      return cons

   def objcoef(me, expr):
      for i,c in expr.mat:
         me.p.obj[i] = c
      me.p.obj[None] = expr.const #linexp

   def max(me, expr, name=None):
      me.fobj(True, expr, name)

   def min(me, expr, name=None):
      me.fobj(False, expr, name)

   def fobj(me, maximize, expr, name):
      me.p.obj.maximize = maximize
      me.p.obj.name = name
      if type(expr) is variable:
         expr = +expr #convert to expression
      if type(expr) is not parex:
         raise Exception, "bad objective type"
      objective(expr).bind(me)
      if me.verb:
         name = '' if name==None else name
         impr = "MAX" if maximize else "MIN"
         print "%s '%s':"%(impr, name),
         print expr

   kind = property(lambda me: me.p.kind)

   def status(me): return me.p.status

   def nint(me): 
      """Get number of integer variables."""
      return me.p.nint()

   def nbin(me): 
      """Get number of binary variables."""
      return me.p.nbin()

   def solve(me, t=None):
       """you can change parameters, then the model will
rebuild itself before actually solve."""
       param.updateAll() #this takes care of rebuilding
       ret = {}
       meth=me.options.get('method')
       if meth == 'interior':
          ret[meth] = me.p.interior()
       elif meth == 'exact':
          ret[meth] = me.p.exact()
       else: 
          keywds=("msg_lev", "meth", "pricing", 
          "r_test", "tol_bnd", "tol_dj", "tol_piv",
          "obj_ll", "obj_ul", "it_lim", "tm_lim", 
          "out_frq", "out_dly", "presolve") 
          keywds=extract_keys(me.options, keywds)
          ret['simplex'] = me.p.simplex(**keywds)

       if t==None: t=me.kind
       if t != int: return ret
       meth=me.options.get('integer')
       ret[meth] = me.solveMIP()
       return ret

   def solveMIP(me):
       """Solve the model using only MIP methods,
assuming you have solved the LP relaxation.
return solver status."""
       meth=me.options.get('integer')
       if meth == 'advanced':
          return me.p.intopt()
       else: 
          #note: if your glpk version is too old,
          #some options might not be supported.
          keywds=("msg_lev", "br_tech", "bt_tech",
          "pp_tech", "gmi_cuts", "mir_cuts", 
          "tol_int", "tol_obj", "tm_lim", "out_frq", 
          "out_dly", "callback")
          keywds=extract_keys(me.options, keywds)
          return me.p.integer(**keywds)

   def kkt(me, kind=None):
      """Karush-Kuhn-Tucker optimality conditions for 
1. a basic (simplex) solution if kind = float.  
   If the argument 'scaled' is true, return results
   of checking the internal scaled instance of the LP instead.
2. a mixed-integer solution if kind = int.  
   Note that only the primal components
   of the KKT object will have meaningful values.
"""
      if kind is None: kind = me.kind
      return me.p.kkt() if kind is float else\
             me.p.kktint()

   def reportKKT(me, kind=None):
      """produce a convenient report on KKT"""
      if kind is None: kind = me.kind
      res = me.kkt(kind)
      rpt = """
Karush-Kuhn-Tucker optimality conditions:
=========================================

1) Error in Primal Solutions:
-----------------------------
Largest absolute error: %f (row id: %s)
Largest relative error: %f (row id: %s)
Quality of primal solution: %s

2) Error in Satisfying Primal Bounds:
-------------------------------------
Largest absolute error: %f (var id: %s)
Largest relative error: %f (var id: %s)
Quality of primal feasibility: %s
"""%( res.pe_ae_max, res.pe_ae_row, 
      res.pe_re_max, res.pe_re_row,
      res.pe_quality,
      res.pb_ae_max, res.pb_ae_ind,
      res.pb_re_max, res.pb_re_ind,
      res.pb_quality)
      if kind is int: return rpt
      return rpt + """
3) Error in Dual Solutions:
-----------------------------
Largest absolute error: %f (col id: %s)
Largest relative error: %f (col id: %s)
Quality of dual solution: %s

4) Error in Satisfying Dual Bounds:
-------------------------------------
Largest absolute error: %f (var id: %s)
Largest relative error: %f (var id: %s)
Quality of dual feasibility: %s
"""%( res.de_ae_max, res.de_ae_col, 
      res.de_re_max, res.de_re_col,
      res.de_quality,
      res.db_ae_max, res.db_ae_ind,
      res.db_re_max, res.db_re_ind,
      res.db_quality)

   def vobj(me): 
      """value of the objective."""
      return me.p.obj.value

   def scale(me, doit=True): 
      """scale or unscale the problem."""
      if doit: me.p.scale()
      else: me.p.unscale()


   def solvopt(me, **kwds):
      """add/get/del solver options. 
Only accept keyword arguments.
add: solvopt(method='exact');
get: solvopt();
del: solvopt(method=None);"""
      for opt in kwds:
          if kwds[opt] is not None:
             me.options[opt]=kwds[opt]
          elif opt in me.options:
             del me.options[opt]
      if len(kwds)==0: return me.options


   def sensit(me, file_name):
      """write sensitivity report to a file"""
      me.write(sens_bnds=file_name)

   def write(me, **kwds):
      """Output data about the linear program into a file with a given
    format.  What data is written, and how it is written, depends
    on which of the format keywords are used.  Note that one may
    specify multiple format and filename pairs to write multiple
    types and formats of data in one call to this function.
    
    mps       -- For problem data in the fixed MPS format.
    bas       -- The current LP basis in fixed MPS format.
    freemps   -- Problem data in the free MPS format.
    cpxlp     -- Problem data in the CPLEX LP format.
    glp       -- Problem data in the GNU LP format.
    prob      -- Problem data in a plain text format.
    sol       -- Basic solution in printable format.
    sens_bnds -- Bounds sensitivity information.
    ips       -- Interior-point solution in printable format.
    mip       -- MIP solution in printable format.
"""
      me.p.write(**kwds)


class _dirt_(object):
   """The base class for variable, parameter, parex.
The main functionality is to provide numerical type support,
so that the subclasses can be operated by operators like
'+', '-', '*', '/', '**'."""

   def _bad_type(me, b):
       global _good_types
       return type(b) not in _good_types

   def __add__(me, b):
       if me._bad_type(b): return NotImplemented
       return parex(me, '+', b)

   def __radd__(me, b):
       if me._bad_type(b): return NotImplemented
       return parex(me, '+', b)

   def __mul__(me, b):
       if me._bad_type(b): return NotImplemented
       return parex(me, '*', b)

   def __rmul__(me, b):
       if me._bad_type(b): return NotImplemented
       return parex(me, '*', b)

   def __sub__(me, b):
       if me._bad_type(b): return NotImplemented
       return parex(me, '-', b)

   def __rsub__(me, b): # b - me
       if me._bad_type(b): return NotImplemented
       return parex(b, '-', me)

   def __div__(me, b):
       if me._bad_type(b): return NotImplemented
       return parex(me, '/', b)

   def __rdiv__(me, b): #since me could be a const
       if me._bad_type(b): return NotImplemented
       return parex(b, '/', me)

   def __pos__(me): 
       return parex(0, 'ps', me)

   def __neg__(me):
       return parex(0, 'ng', me)

   def __pow__(me, b):
       return parex(me, '**', b)

def isConst(b):
       if type(b) in (int, float, long, param): 
          return True
       if isinstance(b, parex): 
          return b.isConst()
       return not isinstance(b, variable)
 
class param(_dirt_):
   """A parameter, whose value may be changed,
When a parameter changed in value, it will 
add it self to the class owned dirty list.
Each param also maintains its own list of listeners. 
The listeners can be parex or variable objects.
A class method is also provided to fire off the
updating process.
"""

   #another design may put this field under
   #a model instance, which makes sense if
   #a param must belong to a model instance.
   #We don't enforce that, and allow a param
   #to play in many models simultaneously.
   dirtyset = set() #class member

   @classmethod
   def updateAll(cls):
      updated = set() #update only once
      for p in cls.dirtyset:
         p.updateClients(updated)
      cls.dirtyset = set()
      return updated

   def __init__(me, val=None, name=None):
      if type(val) not in (int, float):
        raise Exception, "Bad parameter value!"
      me._val = val
      me.name = name
      me.clients = set() #for dirt

   def updateClients(me, updated):
      for c in me.clients:
         if c not in updated:
            c.update() #batchid
            updated.add(c)

   def register(me, client):
      """register as clients/listeners."""
      me.clients.add(client)

   def unregister(me, client):
      """unregister as clients/listeners."""
      me.clients.discard(client)

   def set_value(me, val): 
       if val == me._val: return
       me._val = val
       me.dirtyset.add(me)

   def get_value(me): return me._val
   value = property(get_value, set_value)

   def __repr__(me): 
      return "%s=%s"%(me.name,str(me._val))

class variable(_dirt_):
   """Represents a variable. 
Set bounds using x.bounds = (A, B) for x in [A,B].
If A or B is an expression containing parameters, 
then parameters changes will update the bounds.
To fix a variable at constant C, use x.bounds=(C,C).
Another easier way to set bounds: A <= x <= B.

Note: it is OK to use the st call to set a constraint
like this: st( A <= x <= B).
Basically, a variable is passed to st(), then 
st() converts it into an expression '0+x', and
then use the bounds on x to construct the constraint,
So be ware of the side effect: 
(1) the bounds on x changed and more subtly 
(2) the constraint is surely redundant as the
    bounds on x effectly ensures the same thing.
To ensure you bounds won't be modified by such 
constraints, it is recommended to set bounds of x 
after all constraints. Or, you can equivalently 
write: st(0 <= x - A <= B-A).
"""

   def __init__(me, col, name=None, kind=None, bounds=None):
       if kind==None: kind=float
       if bounds==None: bounds = 0, None
       me.x = col
       me._bexp = (0, None) #bound expression
       me.set_bounds(bounds)
       #note: if kind=bool, then bounds<-(0,1)
       col.kind = kind #must follow set_bounds
       col.name = name

   def check_bexp(me, lh):
      if lh is None: return
      if me._bad_type(lh):
         raise Exception, "Bad bound type!"
      if not isConst(lh):
         raise Exception, "Bound not constant!"

   def get_bounds(me): return me.x.bounds
   def set_bounds(me, b): 
      """If b is a parex containing param instances,
me must register to those params."""
      if b is None: b = 0, None
      for i in b: me.check_bexp(i)
      for p in me._depends(): 
         p.unregister(me)
      me._bexp = b
      for p in me._depends(): 
         p.register(me)
      me.update()

   bounds = property(get_bounds, set_bounds)

   def _depends(me):
      """enumerate all parameters the bounds depend on."""
      def check(x): return isinstance(x, param)
      for b in me._bexp:
         if check(b): yield b
         elif isinstance(b, parex):
            for c in b.preorder(check):
               yield c

   def update(me): #bounds
      lo, hi = me._bexp
      if type(lo) in (param, parex):
         lo = lo.value #no variables
      if type(hi) in (param, parex):
         hi = hi.value #no variables
      if hi is not None and lo > hi: 
         print "Bound error:",str(me)
      me.x.bounds = lo, hi

   def get_kind(me): return me.x.kind
   def set_kind(me, k): me.x.kind = k
   kind = property(get_kind, set_kind)

   status = property(lambda me: me.x.status)

   primal = property(lambda me: me.x.primal)

   dual = property(lambda me: me.x.dual)

   def get_name(me): return me.x.name
   def set_name(me, n): me.x.name=n
   name = property(get_name, set_name)

   def __repr__(me):
       c = me.x
       return "%s=%f"%(c.name, c.primal)

   def __str__(me):
       c = me.x
       return "%s=%f"%(c.name, c.primal)

   def __le__(me, b):
       if me._bad_type(b): return NotImplemented
       if isConst(b):
          me.bounds = (me._bexp[0], b)
          return me
       return constraint(None, me-b, 0)

   def __ge__(me, b): 
       if me._bad_type(b): return NotImplemented
       if isConst(b):
          me.bounds = (b, me._bexp[1])
          return me
       return constraint(0, me-b, None)

   def __eq__(me, b):
       if me._bad_type(b): return NotImplemented
       if isConst(b):
          me.bounds = (b, b)
          return me
       return constraint(0, me-b, 0)

   def bind(me, row, name):
       """bind this variable as a constraint"""
       a,b = me._bexp
       #print +me <= None # False
       con = constraint(a, +me, b)
       return con.bind(row, name)

   """
   def __del__(me):
      for p in me._depends(): 
         p.unregister(me)
      del me._bexp
      print "deleting "+me.name
   """

class objective(object):
   """An objective, which takes care of automatic update."""
   def __init__(me, expr):
       me.expr = expr
       me.relates()

   def relates(me):
       def check(x): return isinstance(x, param)
       for p in me.expr.preorder(check):
          p.register(me)

   def update(me):
       me.mod.objcoef(me.expr.linearize())

   def bind(me, mod):
       """bind the objective to a model."""
       me.mod = mod
       me.update()

   """
   def __del__(me):
       me.relates(False)
   """

class constraint(object):
   """A constraint. Such an object is 
created by a comparison (<=, >=, or ==)
between parexs."""

   def __init__(me, lo, expr, hi):
      me.lo = lo
      me.expr = expr
      me.hi = hi
      me.row = None

   def get_bounds(me): return me.row.bounds
   def set_bounds(me, b): me.row.bounds = b
   bounds = property(get_bounds, set_bounds)

   status = property(lambda me: me.row.status)

   primal = property(lambda me: me.row.primal)

   dual = property(lambda me: me.row.dual)

   def get_name(me): return me.row.name
   def set_name(me, n): me.row.name=n
   name = property(get_name, set_name)

   def relates(me):
      """register for possible changes."""
      def check(x): return isinstance(x,param)
      for p in me.expr.preorder(check):
         p.register(me)
      for b in (me.lo, me.hi):
         if check(b): b.register(me)
         elif isinstance(b, parex):
            for p in b.preorder(check):
                p.register(me)

   def vbounds(me):
       """value of bounds"""
       lo, hi = me.lo, me.hi
       if type(me.lo) in (param, parex):
          lo = me.lo.value #no variables
       if type(me.hi) in (param, parex):
          hi = me.hi.value #no variables
       return lo, hi

   def update(me): #update row (usually before solve)
       rex = me.expr.linearize()
       lo, hi = me.vbounds()
       if lo is not None: lo -= rex.const #linexp
       if hi is not None: hi -= rex.const #linexp
       me.row.bounds = lo, hi
       me.row.matrix = rex.matrix()

   def bind(me, row, name):
       """bind this constraint to a row."""
       row.name = name
       me.row = row
       me.update() #active update
       me.relates()
       return me

   def __repr__(me):
       ret = 's.t. %s: '
       if me.row: ret = ret%me.row.name
       if me.lo is not None and me.lo != me.hi: 
          ret += repr(me.lo) + " <= "
       ret += repr(me.expr)
       if me.hi is not None: 
          ret +=  " <= " if me.lo != me.hi else " == "
          ret += repr(me.hi)
       return ret

   def __str__(me):
       ret = 's.t. %s: '
       if me.row: ret = ret%me.row.name
       if me.lo is not None and me.lo != me.hi: 
          ret += str(me.lo) + " <= "
       ret += str(me.expr)
       if me.hi is not None: 
          ret +=  " <= " if me.lo != me.hi else " == "
          ret += str(me.hi)
       return ret


class parex(_dirt_):
   """expression that can take parameter objects.
When parameters change, parex sits in the middle
to have the model updated.
"""

   def __init__(me, left, op, rite):
      me.left = left
      me.op = str(op) #must be str 
      me.rite = rite
      me.constr = not (isConst(left) and isConst(rite))

   def isConst(me): return not me.constr

   @staticmethod
   def pretty_push(expr, op, nodes):
      def priority(op):
         if op in ('<=', '>=', '=='):
            return -1
         return ['+','-','*','/','ps','ng','**'].index(op)/2

      if isinstance(expr, parex):
         if priority(expr.op) < priority(op):
            nodes.append(')')
            nodes.append(expr)
            nodes.append('(')
         else: nodes.append(expr)
      else: nodes.append(expr)

   def pinorder(me):
      """pretty inorder traversal for print."""
      nodes = [me] #for tree traversion
      while len(nodes)>0:
         cur = nodes.pop() #explore
         if not isinstance(cur, parex):
            yield cur; continue
         me.pretty_push(cur.rite, cur.op, nodes)
         nodes.append(cur.op)
         if cur.op in ('ps','ng'): continue
         me.pretty_push(cur.left, cur.op, nodes)

   def __repr__(me):
      ret = ""
      for i in me.pinorder():
         if type(i) in (param, variable):
            ret += i.name
         elif i in ('ps', 'ng'): 
            ret += {'ps':'+','ng':'-'}[i]
         elif type(i) is str:
            ret += i
         else: ret += repr(i)
      return ret

   def __str__(me):
      cols = {}
      def check(x): return isinstance(x, variable)
      for v in me.preorder(check): 
         cols[v.x.index]=v.x
      lexp = me.linearize()
      return lexp.tostr(cols)

   def preorder(me, check=lambda x:True):
      """reversed preorder traversal."""
      nodes = [me] #for tree traversion
      while len(nodes)>0:
         cur = nodes.pop() #explore
         if not isinstance(cur, parex):
            if check(cur): yield cur
            continue
         nodes.append(cur.op)
         nodes.append(cur.left)
         nodes.append(cur.rite)

   def linearize(me, const=None): 
       """
convert this expression to a linexp.
returns a linexp or a number.
"""
       stack = []
       for t in me.preorder():
          tt = type(t)
          if tt in (int, float, long):
             stack.append(t)
          elif isinstance(t, param):
             stack.append(t.value)
          elif isinstance(t, variable):
             if const: raise Exception,\
                   "Not a constant!"
             stack.append(linexp(t)\
               if const is None else t.primal)
          else: stack.append({ #switch(t) 
            '+': lambda a,b: a+b,
            '-': lambda a,b: a-b,
            '*': lambda a,b: a*b,
            '/': lambda a,b: (a+0.0)/b,
            '**': lambda a,b: a**b,
            '<=': lambda a,b: a<=b,
            '>=': lambda a,b: a>=b,
            '==': lambda a,b: a==b,
            'ps': lambda a,b: +b,
            'ng': lambda a,b: -b
          }[t](stack.pop(), stack.pop()))
       assert len(stack)==1
       return stack[0]


   def evaluate(me): 
       """
evaluate this expression to a number with
variables taking their primal values.
"""
       return me.linearize(False)

   #the value when the parex is a constant 
   value = property(lambda me: me.linearize(True))

   def __le__(me, b): #me <= b
       """
   when you have something like this:
     rex = (expr1 <= expr2 <= expr3)
   the rex gets 'expr2 <= expre3',
   and the constraint 'expr1 <= expr2' is lost
   (when expr1 or expr3 contains variables, 
    the constraint is not well defined).
   However, if expr1 and expr3 are CONSTANTS,
   such as: 0 <= expr <= 3, then nothing is lost.
   'expr' must be an parex that is not a constant."""
       if me._bad_type(b): return NotImplemented
       if isConst(me) and isConst(b):
          return parex(me, "<=", b)
       if not isConst(me) and not isConst(b):
          return constraint(None, me-b, 0)
       if not isConst(me): 
          if me.constr is True:
             me.constr = constraint(None, me, b)
          else: #had been compared before
             if me.constr.hi: # a >= me <= b
               print "WARNING: overriding hi"
             me.constr.hi = b
          return me.constr
       if isinstance(b, variable):
          return constraint(0, b - me, None)
       if b.constr is True:
             b.constr = constraint(me, b, None)
       else: #had been compared before
             b.constr.lo = me
       return b.constr


   def __ge__(me, b): # me >= b
       if me._bad_type(b): return NotImplemented
       if isConst(me) and isConst(b):
          return parex(me, ">=", b)
       if not isConst(me) and not isConst(b):
          return constraint(0, me-b, None)
       if not isConst(me): 
          if me.constr is True:
             me.constr = constraint(b, me, None)
          else: #had been compared before
             if me.constr.lo: # a <= me >= b
               print "WARNING: overriding lo"
             me.constr.lo = b
          return me.constr
       if isinstance(b, variable):
          return constraint(None, b-me, 0)
       if b.constr is True:
             b.constr = constraint(None, b, me)
       else: #had been compared before
             b.constr.hi = me
       return b.constr

   def __eq__(me, b):
       if me._bad_type(b): return NotImplemented
       if isConst(me) and isConst(b):
          return parex(me, "==", b)
       if isConst(me): return constraint(me, b, me)
       if isConst(b): return constraint(b, me, b)
       if me.constr is not True:
          #possibly: expr <= me == b
          print "WARNING: discarding constraint."
       return constraint(0, me-b, 0)


class linexp(object): #linear expressions
   """class linexp for pymprog.
   this class facilitates constraints evaluation.
   """

   def __init__(me, var=None, coef=1.0):
       me.const = 0
       me.mat = []
       if var!=None: 
          me.mat.append((var.x.index,coef))

   def matrix(me): #get the corresponding matrix row
       return me.mat

   def transmat(me, u):
      u.const= me.const
      u.mat = me.mat[:]

   def tostr(me, cols):
       ret, s = '', ''
       for i,cf in me.mat:
           cf = s if cf==1 else '- ' if cf==-1 else\
              "%s%g "%(s,cf) if cf>=0 else "%g "%cf
           ret += "%s%s"%(cf, cols[i].name)
           s = '+ ' # after first item, use '+'
       if me.const < 0: ret += str(me.const)
       if me.const > 0: ret += '+' + str(me.const)
       return ret

   def _bad_type(me, b):
       return type(b) not in (int, float, long, linexp)

   #If one of those methods does not support the operation with 
   #the supplied arguments, it should return NotImplemented.
   def __add__(me, b):
       if me._bad_type(b): return NotImplemented
       rex = linexp()
       me.transmat(rex)
       if type(b) in (int, long, float):
          rex.const += b
          return rex
       #assert type(b) == linexp:
       rex.const += b.const
       j = 0      
       for i,v in b.mat:
          while j<=len(rex.mat):
             if j==len(rex.mat):
                rex.mat.append((i,v))
                break
             vid, cf = rex.mat[j]
             if vid == i:
                rex.mat[j] = (i, cf+v)
                j += 1
                break
             if vid > i:
                rex.mat.insert(j,(i,v))
                j += 1
                break
             j += 1 # vid < i
       return rex

   def __radd__(me, b):
       if me._bad_type(b): return NotImplemented
       return me + b

   def __mul__(me, b):
       if type(b) not in (int, float):
          return NotImplemented
       rex = linexp()
       rex.const = me.const*b
       rex.mat = [(i,c*b) for i,c in me.mat]
       return rex

   def __rmul__(me, b):
       if type(b) not in (int, float):
          return NotImplemented
       return me * b

   def __sub__(me, b):
       if me._bad_type(b): return NotImplemented
       return me + b*(-1.0)

   def __rsub__(me, b): # b - me
       if me._bad_type(b): return NotImplemented
       return me*(-1.0) + b

   def __div__(me, b):
       if type(b) not in (int, long, float):
          return NotImplemented
       return me * (1.0/b)

   def __pos__(me): 
       return me 

   def __neg__(me):
       return me*(-1.0)

_good_types = (
     int, float, long, type(None),
     variable, param, parex)