CouenneExpression.hpp

Go to the documentation of this file.

/* $Id: CouenneExpression.hpp 1147 2015-05-04 14:01:51Z stefan $
 *
 * Name:    expression.hpp
 * Author:  Pietro Belotti
 * Purpose: definition of the class expression
 *
 * (C) Carnegie-Mellon University, 2006-10.
 * This file is licensed under the Eclipse Public License (EPL)
 */

#ifndef COUENNE_EXPRESSION_HPP
#define COUENNE_EXPRESSION_HPP

#include <iostream>
#include <set>
#include <vector>

#include "CouennePrecisions.hpp"
#include "CouenneTypes.hpp"

class OsiBranchingInformation;
class OsiSolverInterface;
class OsiCuts;

namespace Couenne {

class CouenneProblem;
class CouenneCutGenerator;
class CouenneObject;

class exprAux;
class exprCopy;
class exprVar;

class DepNode;
class DepGraph;

class Domain;

struct compNode;


class expression {

 public:

  enum auxSign {AUX_UNDEF=-2, AUX_LEQ=-1, AUX_EQ, AUX_GEQ};

  expression () {}

  expression (const expression &e, Domain *d = NULL) {}

  virtual ~expression () {}

  virtual expression *clone (Domain *d = NULL) const 
  {return NULL;}

  virtual inline int Index () const
  {return -1;}

  virtual inline int nArgs () const
  {return 0;}

  virtual inline expression **ArgList () const
  {return NULL;}

  virtual inline void ArgList (expression **al) {}

  virtual inline expression *Argument () const
  {return NULL;}

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

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

  virtual inline expression *Image () const
  {return NULL;}

  virtual void Image (expression *image) {}

  virtual inline CouNumber Value () const 
  {return 0.;}

  virtual inline const expression *Original () const 
  {return this;}

  virtual void print (std::ostream &s  = std::cout,   
                      bool             = false) const 
  {s << '?';}

  virtual CouNumber operator () () = 0;

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

  virtual expression *differentiate (int);

  virtual int dependsOn (int *ind, int n, enum dig_type type = STOP_AT_AUX);

  inline int dependsOn (int singleton, enum dig_type type = STOP_AT_AUX)
  {return dependsOn (&singleton, 1, type);}

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

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

  virtual inline int Linearity ()
  {return NONLINEAR;}

  virtual inline bool isDefinedInteger ()
  {return isInteger ();}

  virtual inline bool isInteger ()
  {return false;}

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

  virtual void getBounds (CouNumber &, CouNumber &);

  virtual inline exprAux *standardize (CouenneProblem *p, bool addAux = true) 
  {return NULL;}

  virtual void generateCuts (expression *w, //const OsiSolverInterface &si, 
                             OsiCuts &cs, const CouenneCutGenerator *cg,
                             t_chg_bounds *chg = NULL, int wind = -1, 
                             CouNumber lb = -COUENNE_INFINITY, 
                             CouNumber ub =  COUENNE_INFINITY) {}

  virtual enum expr_type code () 
  {return COU_EXPRESSION;}

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

  virtual int compare (expression &);

  virtual int compare (exprCopy   &);

  virtual int rank ()
  {return -1;} // return null rank

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

  virtual inline int Multiplicity ()
  {return 1;}

  virtual CouNumber selectBranch (const CouenneObject *obj, 
                                  const OsiBranchingInformation *info,
                                  expression * &var, 
                                  double * &brpts, 
                                  double * &brDist, // distance of current LP
                                                    // point to new convexifications
                                  int &way)
  {var = NULL; return 0.;}

  virtual void replace (exprVar *, exprVar *) {}

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

  virtual void linkDomain (Domain *d) {}

  virtual void realign (const CouenneProblem *p) {}

  virtual bool isBijective() const 
  {return false;}

  virtual CouNumber inverse (expression *vardep) const
  {return -COUENNE_INFINITY;}

  virtual void closestFeasible (expression *varind, expression *vardep,
                                CouNumber& left, CouNumber& right) const;

  virtual bool isCuttable (CouenneProblem *problem, int index) const
  {return true;}

  virtual bool isaCopy () const
  {return false;}

  virtual expression *Copy () const
  {return NULL;}
};


inline bool updateBound (register int sign, 
                         register CouNumber *dst, 
                         register CouNumber src) {

  // meaning: 
  //
  // if (*dst > src) && (sign > 0) --> dst down to src
  // if (*dst < src) && (sign < 0) --> dst up   to src
  //
  // that is, sign > 0 means we are tightening an UPPER bound
  //          sign < 0                            LOWER

  register double delta = (sign > 0) ? (*dst - src) : (src - *dst);

  if (delta > 0.) {
    //printf ("%.12g --> %.12g\n", *dst, src);
    *dst = src; // tighten
    return (delta > COUENNE_EPS); // avoid returning true when improvement is negligible
  }

  return false;
}


inline int compareExpr (const void *e0, const void *e1)
{return ((*(expression **) e0) -> compare (**(expression **)e1));}


inline bool isInteger (CouNumber x)
{return (fabs (COUENNE_round (x) - x) < COUENNE_EPS_INT);}


inline expression *getOriginal (expression *e) {

  if (e -> isaCopy ()) return getOriginal (e -> Copy ());
  else return e;
}

inline expression *Simplified (expression *complicated) {

  expression *simpler = complicated -> simplify ();

  if (simpler) {
    delete complicated;
    return simpler;
  } else return complicated;
}

}

#endif