CouenneExprOpp.hpp

Go to the documentation of this file.

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

#ifndef COUENNE_EXPROPP_HPP
#define COUENNE_EXPROPP_HPP

#include "CouennePrecisions.hpp"
#include "CouenneExprUnary.hpp"

namespace Couenne {


inline CouNumber opp (register CouNumber arg) 
{return - arg;}



class exprOpp: public exprUnary {

 public:

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

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

  inline unary_function F () 
    {return opp;}

  void print (std::ostream &out, 
              bool descend) const;

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

  expression *differentiate (int index); 

  virtual expression *simplify ();

  inline int Linearity ()
    {return argument_ -> Linearity ();}

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

  void getBounds (CouNumber &, CouNumber&);

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

  virtual enum expr_type code () 
    {return COU_EXPROPP;}

  bool isInteger ()
    {return argument_ -> isInteger ();}

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

  exprAux *standardize (CouenneProblem *, bool addAux = true);
};

}

#endif