/home/coin/SVN-release/OS-2.0.1/Couenne/src/expression/exprVar.hpp

Go to the documentation of this file.
00001 /* $Id: exprVar.hpp 156 2009-06-16 20:24:38Z 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-08. 
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 namespace Bonmin {
00024   class BabSetupBase;
00025 }
00026 
00027 
00032 
00033 class exprVar: public expression {
00034 
00035  protected:
00036 
00037   int varIndex_;   
00038   Domain *domain_; 
00039 
00040  public:
00041 
00043   virtual inline enum nodeType Type () const
00044   {return VAR;}
00045 
00047   exprVar (int varIndex, Domain *d = NULL):
00048     varIndex_ (varIndex),
00049     domain_   (d) {}
00050 
00052   virtual ~exprVar () {}
00053 
00055   exprVar (const exprVar &e, Domain *d = NULL):
00056     varIndex_ (e.varIndex_),
00057     domain_   (d) {}
00058 
00060   virtual inline exprVar *clone (Domain *d = NULL) const
00061   {return new exprVar (*this, d);}
00062 
00064   inline int Index () const
00065   {return varIndex_;}
00066 
00067   // Bounds
00068   virtual expression *Lb (); 
00069   virtual expression *Ub (); 
00070 
00071   // Bounds
00072   virtual inline CouNumber &lb () {return domain_ -> lb (varIndex_);} 
00073   virtual inline CouNumber &ub () {return domain_ -> ub (varIndex_);} 
00074 
00076   virtual void print (std::ostream &out = std::cout,
00077                       bool = false) const
00078   {out << "x_" << varIndex_;}
00079 
00081   virtual inline CouNumber operator () () 
00082   {return domain_ -> x (varIndex_);}
00083 
00085   virtual inline CouNumber gradientNorm (const double *x)
00086   {return 1.;}
00087 
00089   virtual inline expression *differentiate (int index) 
00090     {return new exprConst ((index == varIndex_) ? 1. : 0.);}
00091 
00094   virtual inline int DepList (std::set <int> &deplist, 
00095                               enum dig_type type = ORIG_ONLY) {
00096 
00097     if (deplist.find (varIndex_) == deplist.end ()) {
00098       deplist.insert (varIndex_); 
00099       return 1;
00100     }
00101     return 0;
00102   }
00103 
00106   virtual inline void crossBounds () {}
00107 
00109   virtual inline expression *simplify () 
00110   {return NULL;}
00111 
00113   virtual inline int Linearity ()
00114   {return LINEAR;}
00115 
00117   virtual inline bool isDefinedInteger ()
00118   {return false;}
00119 
00121   virtual inline bool isInteger () {
00122     CouNumber lb = domain_ -> lb (varIndex_);
00123     return ((fabs (lb - domain_ -> ub (varIndex_)) < COUENNE_EPS) && (::isInteger (lb)));
00124   }
00125 
00127   virtual void getBounds (expression *&, expression *&);
00128 
00130   virtual void getBounds (CouNumber &lb, CouNumber &ub);
00131 
00133   //virtual inline void getBounds (CouNumber &lb, CouNumber &ub) {
00134   //lb = domain_ -> lb (varIndex_);
00135   //ub = domain_ -> ub (varIndex_);
00136   //}
00137 
00139   virtual void generateCuts (const OsiSolverInterface &, 
00140                              OsiCuts &, const CouenneCutGenerator *, 
00141                              t_chg_bounds * = NULL, int = -1, 
00142                              CouNumber = -COUENNE_INFINITY, 
00143                              CouNumber =  COUENNE_INFINITY) {}
00144 
00146   virtual void generateCuts (expression *w, 
00147                              const OsiSolverInterface &si, 
00148                              OsiCuts &cs, const CouenneCutGenerator *cg, 
00149                              t_chg_bounds * = NULL, int = -1, 
00150                              CouNumber = -COUENNE_INFINITY, 
00151                              CouNumber =  COUENNE_INFINITY);
00152 
00154   virtual inline enum expr_type code () 
00155   {return COU_EXPRVAR;}
00156 
00158   virtual bool impliedBound (int, CouNumber *, CouNumber *, t_chg_bounds *);
00159 
00161   virtual inline int rank () 
00162   {return 1;}
00163 
00165   virtual void fillDepSet (std::set <DepNode *, compNode> *, DepGraph *);
00166 
00168   virtual inline bool isFixed ()
00169   {return (fabs (lb () - ub ()) < COUENNE_EPS);}
00170 
00172   virtual inline void linkDomain (Domain *d)
00173   {domain_ = d;}
00174 
00176   virtual inline Domain *domain ()
00177   {return domain_;}
00178 
00179   // empty for compatibility
00180   virtual inline void decreaseMult () {}
00181 
00183   virtual inline void zeroMult () {}
00184 
00186   virtual inline void setInteger (bool value) {}
00187 
00189   virtual enum convexity convexity () const
00190   {return AFFINE;}
00191 
00194   virtual CouenneObject properObject (CouenneProblem *p, 
00195                                       Bonmin::BabSetupBase *base, 
00196                                       JnlstPtr jnlst_);
00197 };
00198 
00199 #endif

Generated on Thu Oct 8 03:02:56 2009 by  doxygen 1.4.7