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 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
00070 virtual expression *Lb ();
00071 virtual expression *Ub ();
00072
00073
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
00136
00137
00138
00139
00141 virtual void generateCuts (
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
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
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