CouenneExprAux.hpp

Go to the documentation of this file.

/* $Id: CouenneExprAux.hpp 1195 2015-11-24 23:25:31Z pbelotti $
 *
 * Name:    exprAux.hpp
 * Author:  Pietro Belotti
 * Purpose: definition of the auxiliary variable class (used in
 *          standardization and convexification)
 *
 * (C) Carnegie-Mellon University, 2006-10.
 * This file is licensed under the Eclipse Public License (EPL)
 */

#ifndef COUENNE_EXPRAUX_HPP
#define COUENNE_EXPRAUX_HPP

#include <iostream>
#include <assert.h>

#include "CouenneExprVar.hpp"

namespace Couenne {

class CouenneCutGenerator;

class exprAux: public exprVar {

 public:

  enum intType {Unset=-1, Continuous, Integer};

 protected:

  expression *image_;

  expression *lb_;

  expression *ub_;

  int rank_;

  int multiplicity_;

  enum intType integer_;

  bool top_level_;

  enum auxSign sign_;

 public:

  inline enum nodeType Type () const
  {return AUX;}

  exprAux (expression *, int, int, intType = Unset, Domain * = NULL, enum auxSign = expression::AUX_EQ);

  exprAux (expression *, Domain * = NULL, enum auxSign = expression::AUX_EQ);

  virtual ~exprAux ();

  exprAux (const exprAux &, Domain *d = NULL);

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

  inline expression *Lb () {return lb_;} 
  inline expression *Ub () {return ub_;} 

  virtual void print (std::ostream & = std::cout, 
                      bool = false) const;

  inline expression *Image () const
  {return image_;}

  inline void Image (expression *image)
  {image_ = image;}

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

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

  expression *simplify ();

  inline int Linearity ()
  {return LINEAR;}
    /*return image_ -> Linearity ();*/

  //virtual void getBounds (expression *&lb, expression *&ub);

  void crossBounds ();

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

  virtual inline int rank ()
    {return rank_;} 

  virtual inline bool isDefinedInteger () {

    return ((integer_ == Integer) || 
            ((integer_ == Unset) && 
             ((integer_ = ((image_ != NULL) && (image_ -> isInteger ())) ? 
               Integer : Continuous) == Integer)));
  }

  virtual inline bool isInteger () {

    if (isDefinedInteger ()) 
      return true;

    register CouNumber l = lb ();
    return ((l == ub ()) && (COUENNE_round (l) == l));
    //CouNumber l = (*(Lb ())) ();
    //return (::isInteger (l) && (fabs (l - (*(Ub ())) ()) < COUENNE_EPS));
  }

  virtual inline void setInteger (bool value)
  {integer_ = value ? Integer : Continuous;}

  inline void increaseMult () {++multiplicity_;}

  inline void decreaseMult () {--multiplicity_;}

  inline void zeroMult () {multiplicity_ = 0;}

  inline int Multiplicity () {return multiplicity_;}

  inline void linkDomain (Domain *d) {
    domain_ = d; 
    if (lb_) lb_ -> linkDomain (d);
    if (ub_) ub_ -> linkDomain (d);
  }

  bool &top_level () 
  {return top_level_;}

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

  virtual inline enum auxSign sign () const 
  {return sign_;}
};


struct compExpr {
  inline bool operator () (exprAux* e0, exprAux* e1) const
  {
    int signDiff = (e0 -> sign  () - e1 -> sign  ());

    assert (e0 -> Image () != NULL);
    assert (e1 -> Image () != NULL);

    return ((signDiff < 0) ||
            ((signDiff == 0) &&
             ((e0 -> Image () != NULL) && 
              (e1 -> Image () != NULL) &&
              (e0 -> Image () -> compare (*(e1 -> Image ())) < 0))));
  }
};


void draw_cuts (OsiCuts &, const CouenneCutGenerator *, 
                int, expression *, expression *);

}

#endif