CouenneExprExp.hpp

Go to the documentation of this file.

/* $Id: CouenneExprExp.hpp 615 2011-06-08 20:36:24Z pbelotti $
 *
 * Name:    exprExp.hpp
 * Author:  Pietro Belotti
 * Purpose: definition of the exponential of a function
 *
 * (C) Carnegie-Mellon University, 2006-10.
 * This file is licensed under the Eclipse Public License (EPL)
 */

#ifndef COUENNE_EXPREXP_HPP
#define COUENNE_EXPREXP_HPP

#include <math.h>

#include "CouenneExprUnary.hpp"

namespace Couenne {


class exprExp: public exprUnary {

 public:

  exprExp (expression *al): 
    exprUnary (al) {} //< non-leaf expression, with argument list

  expression *clone (Domain *d = NULL) const
    {return new exprExp (argument_ -> clone (d));}

  inline unary_function F () {return exp;}

  std::string printOp () const
  {return "exp";}

  inline CouNumber gradientNorm (const double *x)
  {return (argument_ -> Index () < 0) ? 0. : exp (x [argument_ -> Index ()]);}

  expression *differentiate (int index); 

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

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

  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 enum expr_type code () {return COU_EXPREXP;}

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

  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);

  virtual bool isBijective() const {return true;}

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

  virtual bool isCuttable (CouenneProblem *problem, int index) const;

  //virtual enum convexity convexity () 
  //{return CONVEX;}
};

}

#endif