00001
00002
00003
00004
00005
00006
00007
00008
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
00068 virtual expression *Lb ();
00069 virtual expression *Ub ();
00070
00071
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
00134
00135
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
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