CouenneExprVar.hpp

Go to the documentation of this file.

/* $Id: CouenneExprVar.hpp 911 2012-10-28 19:50:15Z pbelotti $
 *
 * Name:    exprVar.hpp
 * Author:  Pietro Belotti
 * Purpose: definition of the class exprVar for variables 
 *
 * (C) Carnegie-Mellon University, 2006-10.
 * This file is licensed under the Eclipse Public License (EPL)
 */

#ifndef COUENNE_EXPRVAR_HPP
#define COUENNE_EXPRVAR_HPP

#include <iostream>
#include <set>

#include "CouenneTypes.hpp"
#include "CouenneExpression.hpp"
#include "CouenneExprConst.hpp"
#include "CouenneDomain.hpp"

namespace Ipopt {
  template <class T> class SmartPtr;
  class OptionsList;
  class Journalist;
}

namespace Bonmin {
  class BabSetupBase;
}

namespace Couenne {

  typedef Ipopt::SmartPtr<Ipopt::Journalist> JnlstPtr;
  typedef Ipopt::SmartPtr<const Ipopt::Journalist> ConstJnlstPtr;


class CouenneCutGenerator;


class exprVar: public expression {

 protected:

  int varIndex_;   
  Domain *domain_; 

 public:

  virtual inline enum nodeType Type () const
  {return VAR;}

  exprVar (int varIndex, Domain *d = NULL):
    varIndex_ (varIndex),
    domain_   (d) {}

  virtual ~exprVar () {}

  exprVar (const exprVar &e, Domain *d = NULL):
    varIndex_ (e.varIndex_),
    domain_   (d) {}

  virtual inline exprVar *clone (Domain *d = NULL) const
  {return new exprVar (*this, d);}

  inline int Index () const
  {return varIndex_;}

  // Bounds
  virtual expression *Lb (); 
  virtual expression *Ub (); 

  // Bounds
  virtual inline CouNumber &lb () {return domain_ -> lb (varIndex_);} 
  virtual inline CouNumber &ub () {return domain_ -> ub (varIndex_);} 

  virtual void print (std::ostream &out = std::cout,
                      bool = false) const
  {out << "x_" << varIndex_;}

  virtual inline CouNumber operator () () 
  {return domain_ -> x (varIndex_);}

  virtual inline CouNumber gradientNorm (const double *x)
  {return 1.;}

  virtual inline expression *differentiate (int index) 
  {return new exprConst ((index == varIndex_) ? 1. : 0.);}

  virtual inline int DepList (std::set <int> &deplist, 
                              enum dig_type type = ORIG_ONLY) {

    if (deplist.find (varIndex_) == deplist.end ()) {
      deplist.insert (varIndex_); 
      return 1;
    }
    return 0;
  }

  virtual inline void crossBounds () {}

  virtual inline expression *simplify () 
  {return NULL;}

  virtual inline int Linearity ()
  {return LINEAR;}

  virtual inline bool isDefinedInteger ()
  {return false;}

  virtual inline bool isInteger () {

    // we definitely want to be very conservative here. A continuous
    // variable is integer if and only if its current value is really
    // integer (no round-off) -- see globallib/bearing and term x^(-3.55)

    CouNumber lb = domain_ -> lb (varIndex_);
    return (lb == domain_ -> ub (varIndex_)) && (COUENNE_round (lb) == lb);
  }

  virtual void getBounds (expression *&, expression *&);

  virtual void getBounds (CouNumber &lb, CouNumber &ub);

  //virtual inline void getBounds (CouNumber &lb, CouNumber &ub) {
  //lb = domain_ -> lb (varIndex_);
  //ub = domain_ -> ub (varIndex_);
  //}

  virtual void generateCuts (//const OsiSolverInterface &, 
                             OsiCuts &, const CouenneCutGenerator *, 
                             t_chg_bounds * = NULL, int = -1, 
                             CouNumber = -COUENNE_INFINITY, 
                             CouNumber =  COUENNE_INFINITY) {}

  virtual void generateCuts (expression *w, 
                             //const OsiSolverInterface &si, 
                             OsiCuts &cs, const CouenneCutGenerator *cg, 
                             t_chg_bounds * = NULL, int = -1, 
                             CouNumber = -COUENNE_INFINITY, 
                             CouNumber =  COUENNE_INFINITY);

  virtual inline enum expr_type code () 
  {return COU_EXPRVAR;}

  virtual bool impliedBound (int, CouNumber *, CouNumber *, t_chg_bounds *, enum auxSign = expression::AUX_EQ);

  virtual inline int rank () 
  {return 1;}

  virtual void fillDepSet (std::set <DepNode *, compNode> *, DepGraph *);

  virtual inline bool isFixed ()
  {return (fabs (lb () - ub ()) < COUENNE_EPS);}

  virtual inline void linkDomain (Domain *d)
  {domain_ = d;}

  virtual inline Domain *domain ()
  {return domain_;}

  // empty for compatibility
  virtual inline void decreaseMult () {}

  virtual inline void zeroMult () {}

  virtual inline void setInteger (bool value) {}

  virtual enum convexity convexity () const
  {return AFFINE;}

  virtual CouenneObject *properObject (CouenneCutGenerator *c, 
                                       CouenneProblem *p, 
                                       Bonmin::BabSetupBase *base, 
                                       JnlstPtr jnlst_);

  virtual inline enum auxSign sign () const 
  {return expression::AUX_UNDEF;}
};

}

#endif