exprVar.hpp

Go to the documentation of this file.
00001 /* $Id: exprVar.hpp 259 2009-10-04 14:20:13Z pbelotti $
00002  *
00003  * Name:    exprVar.hpp
00004  * Author:  Pietro Belotti
00005  * Purpose: definition of the class exprVar for variables 
00006  *
00007  * (C) Carnegie-Mellon University, 2006-09.
00008  * This file is licensed under the Common Public License (CPL)
00009  */
00010 
00011 #ifndef COUENNE_EXPRVAR_HPP
00012 #define COUENNE_EXPRVAR_HPP
00013 
00014 #include <iostream>
00015 #include <set>
00016 
00017 #include "CouenneJournalist.hpp"
00018 #include "CouenneTypes.hpp"
00019 #include "expression.hpp"
00020 #include "exprConst.hpp"
00021 #include "domain.hpp"
00022 
00023 class CouenneCutGenerator;
00024 
00025 namespace Bonmin {
00026   class BabSetupBase;
00027 }
00028 
00029 
00034 
00035 class exprVar: public expression {
00036 
00037  protected:
00038 
00039   int varIndex_;   
00040   Domain *domain_; 
00041 
00042  public:
00043 
00045   virtual inline enum nodeType Type () const
00046   {return VAR;}
00047 
00049   exprVar (int varIndex, Domain *d = NULL):
00050     varIndex_ (varIndex),
00051     domain_   (d) {}
00052 
00054   virtual ~exprVar () {}
00055 
00057   exprVar (const exprVar &e, Domain *d = NULL):
00058     varIndex_ (e.varIndex_),
00059     domain_   (d) {}
00060 
00062   virtual inline exprVar *clone (Domain *d = NULL) const
00063   {return new exprVar (*this, d);}
00064 
00066   inline int Index () const
00067   {return varIndex_;}
00068 
00069   // Bounds
00070   virtual expression *Lb (); 
00071   virtual expression *Ub (); 
00072 
00073   // Bounds
00074   virtual inline CouNumber &lb () {return domain_ -> lb (varIndex_);} 
00075   virtual inline CouNumber &ub () {return domain_ -> ub (varIndex_);} 
00076 
00078   virtual void print (std::ostream &out = std::cout,
00079                       bool = false) const
00080   {out << "x_" << varIndex_;}
00081 
00083   virtual inline CouNumber operator () () 
00084   {return domain_ -> x (varIndex_);}
00085 
00087   virtual inline CouNumber gradientNorm (const double *x)
00088   {return 1.;}
00089 
00091   virtual inline expression *differentiate (int index) 
00092     {return new exprConst ((index == varIndex_) ? 1. : 0.);}
00093 
00096   virtual inline int DepList (std::set <int> &deplist, 
00097                               enum dig_type type = ORIG_ONLY) {
00098 
00099     if (deplist.find (varIndex_) == deplist.end ()) {
00100       deplist.insert (varIndex_); 
00101       return 1;
00102     }
00103     return 0;
00104   }
00105 
00108   virtual inline void crossBounds () {}
00109 
00111   virtual inline expression *simplify () 
00112   {return NULL;}
00113 
00115   virtual inline int Linearity ()
00116   {return LINEAR;}
00117 
00119   virtual inline bool isDefinedInteger ()
00120   {return false;}
00121 
00123   virtual inline bool isInteger () {
00124     CouNumber lb = domain_ -> lb (varIndex_);
00125     return ((fabs (lb - domain_ -> ub (varIndex_)) < COUENNE_EPS) && (::isInteger (lb)));
00126   }
00127 
00129   virtual void getBounds (expression *&, expression *&);
00130 
00132   virtual void getBounds (CouNumber &lb, CouNumber &ub);
00133 
00135   //virtual inline void getBounds (CouNumber &lb, CouNumber &ub) {
00136   //lb = domain_ -> lb (varIndex_);
00137   //ub = domain_ -> ub (varIndex_);
00138   //}
00139 
00141   virtual void generateCuts (//const OsiSolverInterface &, 
00142                              OsiCuts &, const CouenneCutGenerator *, 
00143                              t_chg_bounds * = NULL, int = -1, 
00144                              CouNumber = -COUENNE_INFINITY, 
00145                              CouNumber =  COUENNE_INFINITY) {}
00146 
00148   virtual void generateCuts (expression *w, 
00149                              //const OsiSolverInterface &si, 
00150                              OsiCuts &cs, const CouenneCutGenerator *cg, 
00151                              t_chg_bounds * = NULL, int = -1, 
00152                              CouNumber = -COUENNE_INFINITY, 
00153                              CouNumber =  COUENNE_INFINITY);
00154 
00156   virtual inline enum expr_type code () 
00157   {return COU_EXPRVAR;}
00158 
00160   virtual bool impliedBound (int, CouNumber *, CouNumber *, t_chg_bounds *);
00161 
00163   virtual inline int rank () 
00164   {return 1;}
00165 
00167   virtual void fillDepSet (std::set <DepNode *, compNode> *, DepGraph *);
00168 
00170   virtual inline bool isFixed ()
00171   {return (fabs (lb () - ub ()) < COUENNE_EPS);}
00172 
00174   virtual inline void linkDomain (Domain *d)
00175   {domain_ = d;}
00176 
00178   virtual inline Domain *domain ()
00179   {return domain_;}
00180 
00181   // empty for compatibility
00182   virtual inline void decreaseMult () {}
00183 
00185   virtual inline void zeroMult () {}
00186 
00188   virtual inline void setInteger (bool value) {}
00189 
00191   virtual enum convexity convexity () const
00192   {return AFFINE;}
00193 
00196   virtual CouenneObject *properObject (CouenneCutGenerator *c, 
00197                                        CouenneProblem *p, 
00198                                        Bonmin::BabSetupBase *base, 
00199                                        JnlstPtr jnlst_);
00200 };
00201 
00202 #endif

Generated on Wed May 19 03:12:37 2010 for Couenne by  doxygen 1.4.7